{"componentChunkName":"component---src-templates-post-jsx","path":"/[JPA]10/","result":{"data":{"site":{"siteMetadata":{"title":"SUbbb"}},"markdownRemark":{"id":"a41dc548-d976-533a-a680-96e86a627d35","excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. JPQL은 가장 중요한 객체지향 쿼리 언어이다. 💫 객체지향 쿼리 소개  메소드를 사용해 식별자로 엔티티 하나를 조회할 수 있다. 이렇게 조회한 엔티티에 객체 그래프 탐색을 사용하면 연관된 엔티티들을 찾을 수 있고, 아래는 가장 단순한 검색 방법이다. 식별자로 조회 -…","html":"<p><em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em></p>\n<blockquote>\n<p>JPQL은 가장 중요한 객체지향 쿼리 언어이다.</p>\n</blockquote>\n<h2>💫 객체지향 쿼리 소개</h2>\n<p><code class=\"language-text\">em.find()</code> 메소드를 사용해 식별자로 엔티티 하나를 조회할 수 있다. 이렇게 조회한 엔티티에 객체 그래프 탐색을 사용하면 연관된 엔티티들을 찾을 수 있고, 아래는 가장 단순한 검색 방법이다.</p>\n<ul>\n<li>식별자로 조회 - <code class=\"language-text\">em.find()</code></li>\n<li>객체 그래프 탐색 - <code class=\"language-text\">a.getB().getC()</code></li>\n</ul>\n<p>ORM을 사용하면 데이터베이스 테이블이 아닌 엔티티 객체를 대상으로 개발하므로 검색도 테이블이 아닌 엔티티 객체를 대상으로 하는 방법이 필요하다. JPQL은 이런 문제를 해결하기 위해 만들어져서 아래의 특징이 있다.</p>\n<ul>\n<li>테이블이 아닌 객체를 대상으로 검색하는 객체지향 쿼리다.</li>\n<li>SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않는다.</li>\n</ul>\n<blockquote>\n<p>SQL이 \"데이터베이스 테이블을 대상으로 하는 데이터 중심의 쿼리\"라면, JPQL은 \"엔티티 객체를 대상으로 하는 객체지향 쿼리\"다. JPQL을 사용하면 JPA는 이 JPQL을 분석한 다음 적절한 SQL을 만들어 데이터베이스를 조회하고, 조회한 결과로 엔티티 객체를 생성해서 반환한다. </p>\n</blockquote>\n<p>JPA는 JPQL뿐만 아니라 다양한 검색 방법을 제공하고, 아래는 JPA가 공식 지원하는 기능이다.</p>\n<ul>\n<li>JPQL(Java Persistence Query Language)</li>\n<li>Criteria 쿼리: JPQL을 편하게 작성하도록 도와주는 API, 빌더 클래스 모음이다.</li>\n<li>네이티브 SQL: JPA에서 JPQL 대신 직접 SQL을 사용할 수 있다.</li>\n</ul>\n<h3>➰ JPQL 소개</h3>\n<p>JPQL은 <strong>엔티티 객체를 조회하는 객체지향 쿼리</strong>다. SQL을 추상화해서 특정 데이터베이스에 의존하지 않는다. </p>\n<ul>\n<li>문법은 SQL과 비슷하고 ANSI 표준 SQL이 제공하는 기능을 유사하게 지원한다.</li>\n<li>데이터베이스 방언만 변경하면 JPQL을 수정하지 않아도 자연스럽게 데이터베이스를 변경할 수 있다. </li>\n<li>SQL보다 간결하다. 엔티티 직접 조회, 묵시적 조인, 다형성 지원으로 코드가 간결하다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">//쿼리 생성\nString jpql = &quot;select m from Member as m where m.username = &#39;kim&#39;&quot;;\nList&lt;Member&gt; resultList = em.createQuery(jpql, Member.class).getResultList();</code>\n        </deckgo-highlight-code>\n<h3>➰ Criteria 쿼리 소개</h3>\n<p>JPQL을 생성하는 빌더 클래스다. </p>\n<ul>\n<li>문자가 아닌 <code class=\"language-text\">query.select(m).where(...)</code> 처럼 프로그래밍 코드로 JPQL을 작성할 수 있다는 장점이 있다.</li>\n<li>오타가 있어도 컴파일은 성공하고 서버에 배포할 수 있지만, 해당 쿼리가 실행되는 런타임 시점에 오류가 발생한다.</li>\n<li>컴파일 시점에 오류를 발견할 수 있다.</li>\n<li>IDE를 사용하면 코드 자동완성을 지원한다.</li>\n<li>동적 쿼리를 작성하기 편하다.</li>\n<li>하지만 복잡하고 장황하다. 따라서 사용하기 불편할뿐더러, 가독성 또한 좋지 않다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">//Criteria 사용준비\nCriteriaBuilder cb = em.getCriteriaBuilder();\nCriteriaQuery&lt;Member&gt; query = cb.createQuery(Member.class);\n\n//루트 클래스 (조회를 시작할 클래스)\nRoot&lt;Member&gt; m = query.from(Member.class);\n\n//쿼리 생성\nCriteriaQuery&lt;Member&gt; cq =  query.select(m).where(cb.equal(m.get(&quot;usernamen&quot;, &quot;kim&quot;));\n\nList&lt;Member&gt; resultList = em.createQuery(cq).getResultList();</code>\n        </deckgo-highlight-code>\n<ul>\n<li>필드명을 문자로 작성하지 않고 코드로 작성하고 싶다면 <strong>메타 모델</strong>을 사용하면 된다. </li>\n</ul>\n<h3>➰ QueryDSL 소개</h3>\n<p>JPQL 빌더 역할을 한다.</p>\n<ul>\n<li>코드 기반이면서 단순하고 사용하기 쉽다.</li>\n<li>작성한 코드도 JPQL과 비슷해서 가독성이 좋다.</li>\n</ul>\n<blockquote>\n<p>JPA 표준은 아니고, 오픈소스 프로젝트이다.</p>\n</blockquote>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">//준비\nJPAQuery query = new JPAQuery(em);\nQMember member = QMember.member;\n\n//쿼리, 결과조회\nList&lt;Member&gt; members = \n    query.from(member)\n    .where(member.username.eq(&quot;kim&quot;))\n    .list(member);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>annotation 프로세서를 사용해 쿼리 전용 클래스를 만들어야 한다. </p>\n<ul>\n<li><code class=\"language-text\">QMember</code> 는 <code class=\"language-text\">Member</code> 엔티티 클래스를 기반으로 생성한 QueryDSL 쿼리 전용 클래스이다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ 네이티브 SQL 소개</h3>\n<p>SQL을 직접 사용할 수 있는 기능이다. 아래의 경우에 대해 네이티브 SQL을 사용할 수 있다.</p>\n<ul>\n<li>JPQL을 사용해도 특정 데이터베이스에 의존하는 기능을 사용해야 할 때가 있다. (오라클 데이터베이스의 <code class=\"language-text\">CONNECT BY</code>, 특정 데이터베이스에서만 동작하는 SQL 힌트)</li>\n<li>또한 SQL은 지원하지만 JPQL이 지원하지 않는 기능을 사용해야 할 때도 있다.</li>\n</ul>\n<p>단점으로는 <strong>특정 데이터베이스에 의존하는 SQL을 작성</strong>해야 한다는 것이다.</p>\n<ul>\n<li>데이터베이스의 변경은 네이티브 SQL의 수정을 요구한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String sql = &quot;SELECT ID, AGE, TEAM_ID, NAME FROM MEMBER WHERE NAME = &#39;kim&#39;&quot;;\nList&lt;Member&gt; resultList =  em.createNativeQuery(sql, Member.class).getResultList();</code>\n        </deckgo-highlight-code>\n<h3>➰ JDBC 직접 사용, Mybatis 같은 SQL 매퍼 프레임워크 사용</h3>\n<p>JDBC 커넥션에 직접 접근하고 싶으면 JPA는 JDBC 커넥션을 획득하는 API를 제공하지 않으므로 JPA 구현체가 제공하는 방법을 사용해야 한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Session session = entityManager.unwrap(Session.class);\nsession.doWork(new Work() {\n\n  @Override\n  public void execute(Connection connection) throws SQLException {\n    // work...\n  }\n});</code>\n        </deckgo-highlight-code>\n<ul>\n<li>먼저 Hibernate <code class=\"language-text\">Session</code> 을 구하고, <code class=\"language-text\">Session</code> 의 <code class=\"language-text\">doWork()</code> 메소드를 호출하면 된다.</li>\n<li>\n<p>JDBC나 마이바티스를 JPA와 함께 사용하면 영속성 컨텍스트를 적절한 시점에 <strong>강제로 플러시</strong>해야 한다.</p>\n<ul>\n<li>JDBC를 직접 사용하든, SQL 매퍼와 사용하든 모두 JPA를 우회해서 데이터베이스에 접근하는데, 문제는 JPA를 우회하는 SQL에 대해서는 JPA가 전혀 인식하지 못한다는 것이다. </li>\n<li>최악의 경우, 영속성 컨텍스트와 데이터베이스를 불일치 상태로 만들어 <strong>데이터 무결성을 훼손</strong>할 수도 있다.</li>\n</ul>\n</li>\n</ul>\n<p>JPA를 우회해서 SQL을 실행하기 직전에 영속성 컨텍스트를 수동으로 플러시해서 데이터베이스와 영속성 컨텍스트를 동기화하면 이러한 이슈를 해결할 수 있다.</p>\n<hr>\n<h2>💫 JPQL</h2>\n<p>JPQL의 특징이다.</p>\n<ul>\n<li>JPQL은 객체지향 쿼리 언어이다. 따라서 테이블을 대상으로 쿼리하는 것이 아니라 엔티티 객체를 대상으로 쿼리한다.</li>\n<li>JPQL은 SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않는다.</li>\n<li>JPQL은 결국 SQL로 변환된다.</li>\n</ul>\n<h3>➰ 기본 문법과 쿼리 API</h3>\n<p>JPQL도 SQL과 비슷하게 SELECT, UPDATE, DELETE 문을 사용할 수 있다. (엔티티를 저장할 때는 <code class=\"language-text\">em.persist()</code>를 사용하면 되므로 INSERT문은 없다.)</p>\n<ul>\n<li>전체 구조는 SQL과 비슷하다.</li>\n</ul>\n<p><strong>SELECT 문</strong></p>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">SELECT m FROM Member AS m where m.username = &#39;Hello&#39;</code>\n        </deckgo-highlight-code>\n<ul>\n<li><strong>대소문자 구분</strong> : 엔티티와 속성은 대소문자를 구분한다. 하지만 JPQL 키워드는 대소문자를 구분하지 않는다.</li>\n<li><strong>엔티티 이름</strong> : JPQL에서 사용하는 객체는 클래스 명이 아니라 엔티티 명이고 <code class=\"language-text\">@Entity(name=”XXX”)</code> 로 지정할 수 있다. 지정하지 않으면 클래스 명을 기본값으로 사용한다.</li>\n<li><strong>별칭은 필수</strong> : JPQL은 별칭을 필수로 사용해야 한다. 별칭 없이 작성하면 잘못된 문법이라는 오류가 발생한다.</li>\n</ul>\n<p><strong>TypeQuery, Query</strong><br/>\n작성한 JPQL을 실행하려면 쿼리 객체를 만들어야 한다. 쿼리 객체에는 <code class=\"language-text\">TypeQuery</code> 와 <code class=\"language-text\">Query</code> 가 있고 반환 타입 지정에 따라 나뉜다.</p>\n<ul>\n<li>반환할 타입을 명확하게 지정할 수 있으면 <code class=\"language-text\">TypeQuery</code> 객체를 사용한다.</li>\n<li>반환 타입을 명확하게 지정할 수 없으면 <code class=\"language-text\">Query</code> 객체를 사용한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">TypedQuery&lt;Member&gt; query = em.createQuery(&quot;SELECT m FROM Member m&quot;, Member.class);\n\nList&lt;Member&gt; resultList = query.getResultList();\nfor (Member member : resultList) {\n  System.out.println(&quot;member = &quot; + member);\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">em.createQuery()</code> 의 두 번째 파라미터에 반환할 타입을 지정하면 <code class=\"language-text\">TypeQuery</code> 를 반환하고 지정하지 않으면 <code class=\"language-text\">Query</code> 를 반환한다. </li>\n<li>이때는 조회 대상이 <code class=\"language-text\">Member</code> 엔티티이므로 조회 대상 타입이 명확해 <code class=\"language-text\">TypeQuery</code> 를 사용할 수 있다. 명확하지 않다면 <code class=\"language-text\">Query</code> 로 변경하면 된다.</li>\n</ul>\n<p><code class=\"language-text\">Query</code> 객체는 SELECT 절의 조회 대상이 둘 이상이면 <code class=\"language-text\">Object[]</code> 를 반환하고, 조회 대상이 하나면 <code class=\"language-text\">Object</code> 를 반환한다. 타입을 변환할 필요가 없는 <code class=\"language-text\">TypeQuery</code> 를 사용하는 것이 더 편리하다.</p>\n<p><strong>결과 조회</strong><br/>\n다음 메소드들을 호출하면 실제 쿼리를 실행해서 데이터베이스를 조회한다.</p>\n<ul>\n<li><code class=\"language-text\">query.getResultList()</code> : 결과를 예제로 반환한다. 결과가 없으면 빈 컬렉션을 반환한다.</li>\n<li>\n<p><code class=\"language-text\">query.getSingleResult()</code> : 결과가 <strong>정확히 하나</strong>일 때 사용한다.</p>\n<ul>\n<li>결과가 없으면 <code class=\"language-text\">NoResultException</code> 발생한다.</li>\n<li>1개보다 많으면 <code class=\"language-text\">NonUniqueResultException</code> 발생한다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ 파라미터 바인딩</h3>\n<p>JDBC는 위치 기준 파라미터 바인딩만 지원하지만 JPQL은 이름 기준 파라미터 바인딩도 지원한다.</p>\n<p><strong>이름 기준 파라미터</strong><br/>\n파라미터를 이름으로 구분하는 방법으로, 앞에 <code class=\"language-text\">:</code> 를 사용</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String usernameParam = &quot;User1&quot;;\n\nTypedQuery&lt;Member&gt; query = em.createQuery(&quot;SELECT m FROM Member m where m.username = :username&quot;, Member.class);\n\nquery.setParameter(&quot;username&quot;, usernameParam);\nList&lt;Member&gt; resultList = query.getResultList();</code>\n        </deckgo-highlight-code>\n<blockquote>\n<p>참고로 JPQL API는 대부분 메소드 체인 방식으로 설계되어 연속하여 작성이 가능하다.</p>\n</blockquote>\n<p><strong>위치 기준 파라미터</strong><br/>\n<code class=\"language-text\">?</code> 다음에 위치 값을 주어 사용한다. </p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String usernameParam = &quot;User1&quot;;\n\nquery.setParameter(&quot;username&quot;, usernameParam);\nList&lt;Member&gt; resultList = \n    em.createQuery(&quot;SELECT m FROM Member m where m.username = ?1&quot;, Member.class)\n      .setParameter(1, usernameParam)\n      .getResultList();</code>\n        </deckgo-highlight-code>\n<ul>\n<li>위치 기준 파라미터 방식보다는 <strong>이름 기준 파라미터 바인딩 방식</strong>을 사용하는 것이 더 명확하다.</li>\n</ul>\n<blockquote>\n<p>파라미터 바인딩 방식은 선택이 아닌 필수이다.</p>\n</blockquote>\n<h3>➰ 프로젝션</h3>\n<p>SELECT 절에 조회할 대상을 지정하는 것이다. 프로젝션 대상에는 <strong>엔티티</strong>, <strong>임베디드 타입</strong>, <strong>스칼라 타입</strong>(숫자, 문자 등 기본 데이터 타입)이 있다.</p>\n<p><strong>엔티티 프로젝션</strong><br/></p>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">SELECT m FROM Member m      // 회원\nSELECT m.team FROM Member m // 팀</code>\n        </deckgo-highlight-code>\n<ul>\n<li>쉽게 생각하면, 원하는 객체를 바로 조회한 것이다.</li>\n<li>컬럼을 하나하나 나열해서 조회해야하는 SQL과는 차이가 있다.</li>\n<li><strong>조회한 엔티티는 영속성 컨텍스트에서 관리</strong>된다.</li>\n</ul>\n<p><strong>임베디드 타입 프로젝션</strong><br/></p>\n<ul>\n<li>JPQL에서 임베디드 타입은 엔티티와 거의 비슷하게 사용된다. 임베디드 타입은 조회의 시작점이 될 수 없다는 제약이 있다.</li>\n</ul>\n<blockquote>\n<p><strong>임베디드 타입은 엔티티 타입이 아닌 값 타입이기 때문에 직접 조회한 임베디드 타입은 영속성 컨텍스트에서 관리되지 않는다.</strong></p>\n</blockquote>\n<p><strong>스칼라 타입 프로젝션</strong><br/>\n숫자, 문자, 날짜와 같은 기본 데이터 타입들을 스칼라 타입이라 한다. </p>\n<ul>\n<li>통계 쿼리도 주로 스칼라 타입으로 조회한다.</li>\n</ul>\n<p><strong>여러 값 조회</strong><br/>\n엔티티를 대상으로 조회하면 편리하겠지만, 꼭 필요한 데이터들만 선택해서 조회해야 할 때도 있다. </p>\n<ul>\n<li>이때는 프로젝션에 <code class=\"language-text\">Query</code> 를 사용한다.</li>\n<li>역시나 조회한 엔티티는 영속성 컨텍스트에서 관리된다.</li>\n</ul>\n<p><strong>NEW 명령어</strong><br/></p>\n<ul>\n<li>실제 애플리케이션 개발시에는 <code class=\"language-text\">Object[]</code> 를 직접 사용하지 않고 의미있는 객체로 변환해서 사용한다.</li>\n<li>SELECT 다음에 <code class=\"language-text\">NEW</code> 명령어를 사용해 반환받을 클래스를 지정할 수 있다. 클래스의 생성자에 JPQL 조회 결과를 넘겨줄 수 있다.</li>\n</ul>\n<p><code class=\"language-text\">NEW</code> 명령어 사용 시 다음과 같은 주의사항이 있다.</p>\n<ul>\n<li>패키지 명을 포함한 전체 클래스명을 입력해야 한다.</li>\n<li>순서와 타입이 일치하는 생성자가 필요하다.</li>\n</ul>\n<h3>➰ 페이징 API</h3>\n<p>페이징 처리용 SQL을 작성하는 일은 지루하고 반복적이다. 더 큰 문제는 데이터베이스마다 페이징을 처리하는 SQL 문법이 다르다는 것이다.</p>\n<p>JPA는 페이징을 다음 두 API로 추상화했다.</p>\n<ul>\n<li><code class=\"language-text\">setFirstResult(int startPosition)</code> : 조회 시작 위치(0부터 시작한다)</li>\n<li><code class=\"language-text\">setMaxResults(int maxResult)</code> : 조회할 데이터 수</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">TypedQuery&lt;Member&gt; query =\n    em.createQuery(&quot;SELECT m FROM Member m ORDER BY m.username DESC&quot;, Member.class);\n\nquery.setFirstResult(10);\nquery.setMaxResults(20);\nquery.getResultList();</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">setFirstResult(10)</code> 으로, 11번째부터 시작해서 총 20건(<code class=\"language-text\">setMaxResults(20)</code>)의 데이터를 조회한다.</li>\n</ul>\n<p>데이터베이스마다 다른 페이징 처리를 같은 API로 처리할 수 있는 것은 이전에 다룬 <strong>데이터베이스 방언</strong> 덕분이다.</p>\n<h3>➰ 집합과 정렬</h3>\n<p>집합은 집합 함수와 함께 통계 정보를 구할 때 사용한다.</p>\n<p><strong>집합 함수</strong><br/>\n|함수|설명|\n|:---:|:---:|\n|COUNT|결과 수를 구한다. 반환 타입: <code class=\"language-text\">Long</code>|\n|MAX, MIN|최대, 최소 값을 구한다. 문자, 숫자, 날짜 등에 사용한다.|\n|AVG|평균값을 구한다. 숫자타입만 사용할 수 있다. 반환 타입: <code class=\"language-text\">Double</code>|\n|SUM|합을 구한다. 숫자타입만 사용할 수 있다. 반환 타입: 정수합 <code class=\"language-text\">Long</code>, 소수합: <code class=\"language-text\">Double</code>, <code class=\"language-text\">BigInteger</code> 합: <code class=\"language-text\">BigInteger</code>, <code class=\"language-text\">BigDecimal</code> 합: <code class=\"language-text\">BigDecimal</code>|</p>\n<p><strong>참고사항</strong></p>\n<ul>\n<li><code class=\"language-text\">NULL</code> 값은 무시하므로 통계에 잡히지 않는다.</li>\n<li>만약 값이 없는데 집합 함수를 사용하면 <code class=\"language-text\">NULL</code> 값이 된다. 단 <code class=\"language-text\">COUNT</code> 는 0이 된다.</li>\n<li><code class=\"language-text\">DISTINCT</code> 를 집합 함수 안에 사용해서 중복된 값을 제거하고 나서 집합을 구할 수 있다.</li>\n<li><code class=\"language-text\">DISTINCT</code> 를 <code class=\"language-text\">COUNT</code> 에서 사용할 때 임베디드 타입은 지원하지 않는다.</li>\n</ul>\n<p><strong>GROUP BY, HAVING</strong></p>\n<ul>\n<li><code class=\"language-text\">GROUP BY</code> 는 통계 데이터를 구할 때 특정 그룹끼리 묶어준다.</li>\n<li><code class=\"language-text\">HAVING</code> 은 그룹화한 통계 데이터를 기준으로 필터링한다.</li>\n</ul>\n<h3>➰ JPQL 조인</h3>\n<p>SQL 조인과 기능은 같고 문법만 약간 다르다.</p>\n<p><strong>내부 조인</strong><br/>\n<code class=\"language-text\">INNER JOIN</code> 을 사용한다. 여기서 <code class=\"language-text\">INNER</code> 는 생략 가능하다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">SELECT m FROM Member m INNER JOIN m.team t WHERE t.name = :teamName</code>\n        </deckgo-highlight-code>\n<p>JPQL 내부 조인 구문을 보면, SQL의 조인과 약간 다르다. JPQL의 가장 큰 특징은 <strong>연관 필드를 사용</strong>한다는 것이다. 이는 다른 엔티티와 연관관계를 가지기 위해 사용하는 필드이다.</p>\n<ul>\n<li><code class=\"language-text\">FROM Member m</code> : 회원을 선택하고 <code class=\"language-text\">m</code> 이라는 별칭을 주었다.</li>\n<li><code class=\"language-text\">Member m JOIN m.team t</code> : 회원이 가지고 있는 연관 필드로 팀과 조인한다.</li>\n</ul>\n<p><strong>외부 조인</strong><br/></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">SELECT m FROM Member m LEFT [OUTER] JOIN m.team t</code>\n        </deckgo-highlight-code>\n<ul>\n<li>기능상 SQL의 외부 조인과 같다. <code class=\"language-text\">OUTER</code> 는 생략 가능해서 보통 <code class=\"language-text\">LEFT JOIN</code> 으로 많이 사용한다.</li>\n</ul>\n<p><strong>컬렉션 조인</strong><br/>\n일대다 관계나 다대다 관계처럼 컬렉션을 사용하는 곳에 조인하는 것이다.</p>\n<ul>\n<li>[회원 -> 팀] 으로의 조인은 다대일 조인이면서 단일 값 연관 필드(<code class=\"language-text\">m.team</code>)를 사용한다.</li>\n<li>[팀 -> 회원] 으로의 조인은 반대로 일대다 조인이면서 컬렉션 값 연관 필드(<code class=\"language-text\">m.members</code>)를 사용한다.</li>\n</ul>\n<p><strong>세타 조인</strong><br/>\n<code class=\"language-text\">WHERE</code> 절을 사용해서 세타 조인을 사용할 수 있다. 이는 <strong>내부 조인만 지원</strong>하는 조인이다.</p>\n<ul>\n<li>전혀 관계없는 엔티티도 조인할 수 있다.</li>\n</ul>\n<p><strong>JOIN ON 절</strong><br/>\n<code class=\"language-text\">ON</code> 절을 사용하면 조인 대상을 필터링하고 조인할 수 있다. </p>\n<ul>\n<li>내부 조인의 <code class=\"language-text\">ON</code> 절은 <code class=\"language-text\">WHERE</code> 절을 사용하는 것과 결과가 같아, 보통 <code class=\"language-text\">ON</code> 절은 외부 조인에서만 사용한다.</li>\n</ul>\n<h3>➰ 페치 조인</h3>\n<p>SQL에서 다루는 조인의 종류는 아니지만 JPQL에서 성능 최적화를 위해 제공하는 기능이다. </p>\n<ul>\n<li>연관된 엔티티나 컬렉션을 한 번에 같이 조회하는 기능으로, <code class=\"language-text\">join fetch</code> 명령어로 사용할 수 있다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">페치 조인 ::= [ LEFT [OUTER] | INNER ] JOIN FETCH 조인경로</code>\n        </deckgo-highlight-code>\n<p><strong>엔티티 페치 조인</strong><br/>\n연관된 엔티티나 컬렉션을 함께 조회한다.</p>\n<ul>\n<li>별칭을 사용할 수 없다.</li>\n</ul>\n<blockquote>\n<p>Hibernate는 별칭을 허용한다.</p>\n</blockquote>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String jpql = &quot;select m from Member m join fetch m.team&quot;;\nList&lt;Member&gt; members = em.createQuery(jpql, Member.class).getResultList();\nfor (Member member : members) {\n  //페치 조인으로 회원과 팀을 함께 조회해서 지연 로딩 발생 안 함\n  Systern.out.printin(&quot;username = &quot; + member.getUsername () + &quot;, &quot; +\n    &quot;teamname = &quot; + member.getTeam().name());\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>회원과 팀을 지연 로딩으로 설정했다고 가정하면,</p>\n<ul>\n<li>회원 조회 시 페치 조인을 사용해 팀도 함께 조회했으므로 연관된 팀 엔티티는 프록시가 아닌 실제 엔티티다.</li>\n<li>즉, <strong>지연 로딩이 발생하지 않는다.</strong></li>\n</ul>\n</li>\n</ul>\n<p><strong>컬렉션 페치 조인</strong><br/>\n일대다 관계인 컬렉션을 페치 조인한다. </p>\n<ul>\n<li>팀(일)을 조회하면서 페치 조인을 사용해 연관된 회원 컬렉션(다)도 함께 조회한다.</li>\n</ul>\n<blockquote>\n<p>일대다 조인은 결과가 증가할 수 있지만 일대일, 다대일 조인의 결과는 증가하지 않는다.</p>\n</blockquote>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String jpql = &quot;select t from Team t join fetch t.members where t.name = &#39;팀A&#39;&quot;;\nList&lt;Member&gt; teams = em.createQuery(jpql, Team.class).getResultList();\n\nfor (Team team : teams) {\n\n  System.out.println(&quot;teamname = &quot; + team.getName() + &quot;, team = &quot; + team);\n\n  for (Member member : team.getMembers()) {\n    //페치 조인으로 팀과 회원을 함께 조회해서 지연 로딩 발생 안 함\n    Systern.out.printin(&quot;-&gt;username = &quot; + member.getUsername () + &quot;, member = &quot; + member);\n  }\n}</code>\n        </deckgo-highlight-code>\n<p><strong>페치 조인과 DISTINCT</strong><br/></p>\n<ul>\n<li>SQL의 <code class=\"language-text\">DISTINCT</code> 는 중복된 결과를 제거하는 명령어이다.</li>\n<li>JPQL의 <code class=\"language-text\">DISTINCT</code> 명령어는 SQL에 <code class=\"language-text\">DISTINCT</code> 를 추가하는 것은 물론이고 애플리케이션에서 한 번 더 중복을 제거한다.</li>\n</ul>\n<p><strong>페치 조인과 일반 조인의 차이</strong><br/></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 내부 조인 JPQL\nselect t\nfrom Team t join t.members m\nwhere t.name = &#39;팀A&#39;</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">-- 실행된 SQL\nSELECT  T.*\nFROM TEAM TINNER JOIN MEMBER M \nON T.ID=M.TEAM_ID\nWHERE T.NAME = &#39;팀A*&#39;</code>\n        </deckgo-highlight-code>\n<p><strong>JPQL은 결과를 반환할 때 연관관계까지 고려하지 않는다.</strong> 단지 SELECT 절에 지정한 엔티티만 조회할 뿐이다.</p>\n<ul>\n<li>따라서, 팀과 회원 컬렉션을 일반 조인하면 팀 엔티티만 조회하고 연관된 회원 컬렉션은 조회하지 않는다.</li>\n<li>반면 페치 조인을 사용하면 연관된 엔티티도 함께 조회한다.</li>\n</ul>\n<p><strong>페치 조인의 특징</strong><br/>\n페치 조인을 사용하면 SQL 한 번으로 연관된 엔티티들을 함께 조회할 수 있어서 SQL 호출 횟수를 줄여 성능을 최적화할 수 있다.</p>\n<p>다음처럼 엔티티에 직접 적용하는 로딩 전략은 애플리케이션 전체에 영향을 미치므로 <strong>글로벌 로딩 전략</strong>이라고 한다. </p>\n<ul>\n<li><code class=\"language-text\">@OneToMany(fetch = FetchType.LAZY)</code></li>\n<li>페치 조인은 글로벌 로딩 전략보다 우선한다. 즉, 지연 로딩을 글로벌로 설정해도 JPQL에서 페치 조인을 사용하면 페치 조인을 적용한다.</li>\n<li><strong>글로벌 로딩 전략은 지연 로딩을 사용하고 최적화가 필요하면 페치 조인을 적용</strong>하는 것이 성능면에서 효과적이다.</li>\n</ul>\n<p>또한, 페치 조인을 사용하면 연관된 엔티티를 쿼리 시점에 조회하므로 지연 로딩이 발생하지 않는다.</p>\n<ul>\n<li>즉, <strong>준영속 상태에서도 객체 그래프를 탐색</strong>할 수 있다.</li>\n</ul>\n<p><strong>페치 조인의 한계</strong><br/></p>\n<ul>\n<li>\n<p>페치 조인 대상에는 별칭을 줄 수 없다.</p>\n<ul>\n<li>별칭을 잘못 사용하면 연관된 데이터 수가 달라져서 데이터 무결성이 깨질 수 있으므로 조심해서 사용해야 한다.</li>\n<li>특히 2차 캐시와 함께 사용할 때 조심해야 하는데, 연관된 데이터 수가 달라진 상태에서 2차 캐시에 저장되면 다른 곳에서 조회할 때도 연관된 데이터 수가 달라지는 문제가 발생할 수 있다.</li>\n</ul>\n</li>\n<li>\n<p>둘 이상의 컬렉션을 페치할 수 없다.</p>\n<ul>\n<li>구현체에 따라 되기도 하는데 컬렉션 * 컬렉션 카테시안 곱이 만들어 지므로 주의해야 한다.</li>\n</ul>\n</li>\n<li>\n<p>컬렉션을 페치 조인하면 페이징 API(<code class=\"language-text\">setFirstResult</code>, <code class=\"language-text\">setMaxResults</code>)를 사용할 수 없다.</p>\n<ul>\n<li>하이버네이트에서 컬렉션을 페치 조인하고 페이징 API를 사용하면 경고 로그를 남기면서 메모리에서 페이징 처리를 하는데, 데이터가 적으면 상관없겠지만 데이터가 많으면 성능 이슈와 메모리 초과 예외가 발생할 수 있어서 위험하다.</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p>페치 조인은 객체 그래프를 유지할 때 사용하면 효과적이다. 반면에 여러 테이블을 조인해서 엔티티가 가진 모양이 아닌 전혀 다른 결과를 내야 한다면 억지로 페치 조인을 사용하기 보다는 여러 테이블에서 필요한 필드들만 조회해서 <strong>DTO</strong>로 반환하는 것이 더 효과적일 수 있다.</p>\n</blockquote>\n<h3>➰ 경로 표현식</h3>\n<p>.(점)을 찍어 객체 그래프를 탐색하는 것이다.</p>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">select m.username -- 경로 표현식\nfrom Member m\n    join m.team t -- 경로 표현식\n    join m.orders o -- 경로 표현식\nwhere t.name = &#39;팀A&#39; -- 경로 표현식</code>\n        </deckgo-highlight-code>\n<p><strong>용어 정리</strong></p>\n<ul>\n<li>상태 필드(state field) : 단순히 값을 저장하기 위한 필드(필드 또는 프로퍼티)</li>\n<li>\n<p>연관 필드(association field) : 연관관계를 위한 필드, 임베디드 타입 포함(필드 또는 프로퍼티)</p>\n<ul>\n<li>단일 값 연관 필드 : <code class=\"language-text\">@ManyToOne</code> , <code class=\"language-text\">@OneToOne</code> , 대상이 엔티티</li>\n<li>컬렉션 값 연관 필드 : <code class=\"language-text\">@OneToMany</code> , <code class=\"language-text\">@ManyToMany</code> , 대상이 컬렉션</li>\n</ul>\n</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Member {\n\n    @Id @GeneratedValue\n    private Long id;\n\t\t\n    @Column(name=&quot;name&quot;)\n    private String username; // 상태 필드\n    private Integer age; // 상태 필드\n\t\n    @ManyToOne(..)\n    private Team team; // 연관 필드(단일 값 연관 필드)\n\n    @OneToMany(..)\n    private List&lt;Order&gt; orders; // 연관 필드(컬렉션 값 연관 필드)\n    ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>상태 필드 : <code class=\"language-text\">t.username</code>, <code class=\"language-text\">t.age</code></li>\n<li>단일 값 연관 필드 : <code class=\"language-text\">m.team</code></li>\n<li>컬렉션 값 연관 필드 : <code class=\"language-text\">m.orders</code></li>\n</ul>\n<p><strong>경로 표현식과 특징</strong><br/>\n경로 표현식을 사용해 경로 탐색을 위해서는 다음 3가지 경로에 따라 어떤 특징이 있는지 알아야 한다.</p>\n<ul>\n<li>상태 필드 경로 : 경로 탐색의 끝이다. 더는 탐색 불가능하다.</li>\n<li>단일 값 연관 경로 : <strong>묵시적으로 내부 조인</strong>이 일어난다. 단일 값 연관 경로는 계속 탐색할 수 있다.</li>\n<li>컬렉션 값 연관 경로 : <strong>묵시적으로 내부 조인</strong>이 일어난다. 더는 탐색할 수 없다. 단 FROM 절에서 조인을 통해 별칭을 얻으면 별칭으로 탐색할 수 있다.</li>\n</ul>\n<blockquote>\n<p>명시적 조인은 <code class=\"language-text\">JOIN</code> 을 직접 명시하는 것이고, 묵시적 조인은 경로 표현식에 의해 묵시적으로 조인이 일어나는 것으로, 내부 조인(<code class=\"language-text\">INNER JOIN</code>)만 할 수 있다.</p>\n</blockquote>\n<p><strong>컬렉션 값 연관 경로 탐색</strong><br/>\nJPQL을 다루면서 많이 하는 실수 중 하나는 컬렉션 값에서 경로 탐색을 시도하는 것이다.</p>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">select t.members from Team t -- 성공\nselect t.members.username from Team t -- 실패</code>\n        </deckgo-highlight-code>\n<ul>\n<li>컬렉션까지는 경로 탐색이 가능하다. </li>\n<li>하지만 컬렉션에서 경로 탐색을 시작하는 두 번째 예는 허락되지 않는다. 이를 위해서는 조인을 사용해 새로운 별칭을 획득해야 한다.</li>\n</ul>\n<p><strong>경로 탐색을 사용한 묵시적 조인 시 주의사항</strong><br/>\n경로 탐색을 사용하면 묵시적 조인이 발생해 SQL에서 내부 조인이 일어날 수 있다. 이때 주의사항은 다음과 같다.</p>\n<ul>\n<li><strong>항상 내부 조인</strong>이다.</li>\n<li><strong>컬렉션은 경로 탐색의 끝</strong>이다. 컬렉션에서 경로 탐색을 하려면 명시적으로 조인해서 별칭을 얻어야 한다.</li>\n<li>경로 탐색은 주로 SELECT, WHERE 절(다른 곳에서도 사용됨)에서 사용하지만 묵시적 조인으로 인해 SQL의 FROM 절에 영향을 준다.</li>\n</ul>\n<blockquote>\n<p>성능이 주용하면 분석하기 쉽도록 묵시적 조인보다는 <strong>명시적 조인을 사용</strong>하자.</p>\n</blockquote>\n<h3>➰ 서브 쿼리</h3>\n<p>JPQL도 SQL처럼 서브 쿼리를 지원한다. 다음과 같은 제약사항이 존재한다.</p>\n<ul>\n<li>서브 쿼리를 WHERE, HAVING 절에서만 사용할 수 있고,</li>\n<li>SELECT, FROM 절에서는 사용할 수 없다.</li>\n</ul>\n<blockquote>\n<p>Hibernate의 HQL은 SELECT 절의 서브 쿼리도 허용한다.</p>\n</blockquote>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">select m from Member m where m.age &gt; (select avg(m2.age) from Member m2)</code>\n        </deckgo-highlight-code>\n<ul>\n<li>평균보다 나이가 많은 회원을 찾는다.</li>\n</ul>\n<p><strong>서브 쿼리 함수</strong><br/></p>\n<ul>\n<li>[NOT] EXISTS (subquery)</li>\n<li>{ ALL | ANY | SOME } (subquery)</li>\n<li>[NOT] IN (subquery)</li>\n</ul>\n<p><strong>EXISTS</strong></p>\n<ul>\n<li>서브 쿼리에 결과가 존재하면 참이다. NOT은 반대</li>\n</ul>\n<p><strong>{ ALL | ANY | SOME }</strong></p>\n<ul>\n<li>비교 연산자와 같이 사용한다.</li>\n<li>ALL: 조건을 모두 만족하면 참이다.</li>\n<li>ANY 혹은 SOME: 둘은 같은 의미이다. 조건을 하나라도 만족하면 참이다.</li>\n</ul>\n<p><strong>IN</strong></p>\n<ul>\n<li>서브 쿼리의 결과 중 하나라도 같은 것이 있으면 참이다. 서브 쿼리가 아닌 곳에서도 사용한다.</li>\n</ul>\n<h3>➰ 조건식</h3>\n<p><strong>타입 표현</strong>\nJPQL에서 사용하는 타입은 아래와 같이 표시하고, 대소문자는 구분하지 않는다.</p>\n<table>\n<thead>\n<tr>\n<th align=\"center\">종류</th>\n<th align=\"center\">설명</th>\n<th align=\"center\">예제</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td align=\"center\">문자</td>\n<td align=\"center\">작은 따옴표 사이에 표현</td>\n<td align=\"center\">'HELLO', 'She''s'</td>\n</tr>\n<tr>\n<td align=\"center\">숫자</td>\n<td align=\"center\">L(Long), D(Double), F(Float)</td>\n<td align=\"center\">10L, 10D, 10F</td>\n</tr>\n<tr>\n<td align=\"center\">날짜</td>\n<td align=\"center\">Date{d 'yyyy-dd-dd'}<br/>TIME{t 'hh-mm-ss'}<br/>DATETIME{ts 'yyyy-dd-dd hh:mm:ss.f'}</td>\n<td align=\"center\">{d '2012-03-24'}</td>\n</tr>\n<tr>\n<td align=\"center\">Boolean</td>\n<td align=\"center\">TRUE, FALSE</td>\n<td align=\"center\"></td>\n</tr>\n<tr>\n<td align=\"center\">Enum</td>\n<td align=\"center\">패키지명을 포함한 전체 이름을 사용해야 한다.</td>\n<td align=\"center\">jpabook.MemberType.Admin</td>\n</tr>\n<tr>\n<td align=\"center\">엔티티 타입</td>\n<td align=\"center\">엔티티의 타입을 표현한다. 주로 상속과 관련해서 사용한다.</td>\n<td align=\"center\">TYPE(m) = Member</td>\n</tr>\n</tbody>\n</table>\n<p><strong>연산자 우선 순위</strong></p>\n<ol>\n<li>경로 탐색 연산(.)</li>\n<li>수학 연산</li>\n<li>비교 연산</li>\n<li>논리 연산</li>\n</ol>\n<p><strong>컬렉션 식</strong><br/>\n컬렉션에만 사용하는 특별한 기능이다. 컬렉션은 컬렉션 식 이외에 다른 식은 사용할 수 없다.</p>\n<ul>\n<li>\n<p>빈 컬렉션 비교 식</p>\n<ul>\n<li>{ 컬렉션 값 연관 경로 } IS [NOT] EMPTY</li>\n<li>컬렉션에 값이 비었으면 참</li>\n</ul>\n</li>\n<li>\n<p>컬렉션의 멤버 식</p>\n<ul>\n<li>{ 엔티티나 값 } [NOT] MEMBER [OF] { 컬렉션 값 연관 경로 }</li>\n<li>엔티티나 값이 컬렉션에 포함되어 있으면 참</li>\n</ul>\n</li>\n</ul>\n<p><strong>스칼라 식</strong><br/>\n숫자, 문자, 날짜, case, 엔티티 타입 같은 가장 기본적인 타입들을 스칼라라고 한다.</p>\n<ul>\n<li>\n<p>수학 식</p>\n<ul>\n<li>단항 연산자, 사칙연산</li>\n</ul>\n</li>\n<li>\n<p>문자함수</p>\n<ul>\n<li>CONCAT, SUBSTRING, TRIM, LOWER, UPPER, LENGTH, LOCATE</li>\n</ul>\n</li>\n<li>\n<p>수학 함수</p>\n<ul>\n<li>ABS, SQRT, MOD, SIZE, INDEX</li>\n</ul>\n</li>\n<li>\n<p>날짜 함수</p>\n<ul>\n<li>데이터베이스의 현재 시간을 조회한다.</li>\n<li>CURRENT<em>DATE, CURRENT</em>TIME, CURRENT_TIMESTAMP</li>\n</ul>\n</li>\n</ul>\n<p><strong>CASE 식</strong><br/>\n특정 조건에 따라 분기할 때 CASE 식을 사용한다.</p>\n<ul>\n<li>\n<p>기본 CASE</p>\n<ul>\n<li>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">CASE {WHEN &lt;조건식&gt; THEN &lt;스칼라식&gt;} + \nELSE &lt;스칼라식&gt;\nEND</code>\n        </deckgo-highlight-code>\n</li>\n</ul>\n</li>\n<li>\n<p>심플 CASE</p>\n<ul>\n<li>조건식을 사용할 수 없지만, 문법이 단순하다.</li>\n<li>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">CASE &lt;조건대상&gt; + {WHEN &lt;스칼라식1&gt; THEN &lt;스칼라식2&gt;} +\nELSE &lt;스칼라식&gt;\nEND</code>\n        </deckgo-highlight-code>\n</li>\n</ul>\n</li>\n<li>\n<p>COALESCE</p>\n<ul>\n<li>스칼라식을 차례대로 조회해서 <code class=\"language-text\">null</code> 이 아니면 반환한다.</li>\n<li><code class=\"language-text\">COALESCE(&lt;스칼라식> {,&lt;스칼라식>}+)</code></li>\n</ul>\n</li>\n<li>\n<p>NULLIF</p>\n<ul>\n<li>두 값이 같으면 <code class=\"language-text\">null</code> 을 반환하고 다르면 첫 번째 값을 반환한다.</li>\n<li>집합 함수는 <code class=\"language-text\">null</code> 을 포함하지 않아 보통 집합 함수와 함께 사용한다.</li>\n<li><code class=\"language-text\">NULLIF(&lt;스칼라식>, &lt;스칼라식>)</code></li>\n</ul>\n</li>\n</ul>\n<h3>➰ 다형성 쿼리</h3>\n<p>JPQL로 부모 엔티티를 조회하면 그 자식 엔티티도 함께 조회한다.</p>\n<ul>\n<li><code class=\"language-text\">Item</code> 의 자식 엔티티로 <code class=\"language-text\">Book</code> , <code class=\"language-text\">Album</code> , <code class=\"language-text\">Movie</code> 가 있다고 가정한다.</li>\n<li><code class=\"language-text\">Item</code> 을 조회하면 그 자식도 함께 조회한다.</li>\n</ul>\n<p><strong>TYPE</strong><br/>\n엔티티의 상속 구조에서 조회 대상을 특정 자식 타입으로 한정할 때 사용한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// Item 중 Book, Movie를 조회하라.\n\n// JPQL\nselect i from Item i\nwhere type(i) IN (Book, Movie)\n\n// SQL\nSELECT i FROM Item i\nWHERE i.DTYPE in (&#39;B&#39;, &#39;M&#39;)</code>\n        </deckgo-highlight-code>\n<p><strong>TREAT</strong><br/>\nJPA 2.1에 추가된 기능으로, 자바의 타입 캐스팅과 비슷하다. 상속 구조에서 부모 타입을 특정 자식 타입으로 다룰 때 사용한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// JPQL \nselect i from Item i where treat(i as Book).author = &#39;kim&#39;</code>\n        </deckgo-highlight-code>\n<ul>\n<li>부모 타입인 <code class=\"language-text\">Item</code> 을 자식 타입인 <code class=\"language-text\">Book</code> 으로 다뤄 <code class=\"language-text\">author</code> 필드에 접근할 수 있다.</li>\n</ul>\n<h3>➰ 사용자 정의 함수 호출(JPA 2.1)</h3>\n<p><code class=\"language-text\">function_invocation::= FUNCTION(function_name {, function_arg})</code></p>\n<ul>\n<li>Hibernate 구현체를 사용하면 <strong>방언 클래스를 상속</strong>해서 구현하고 사용할 데이터베이스 함수를 미리 등록해야 한다.</li>\n<li>그리고 <code class=\"language-text\">hibernate.dialect</code> 에 해당 방언을 등록해야 한다.</li>\n</ul>\n<h3>➰ 기타 정리</h3>\n<ul>\n<li><code class=\"language-text\">enum</code> 은 = 비교 연산만 지원한다.</li>\n<li>임베디드 타입은 비교를 지원하지 않는다.</li>\n</ul>\n<p><strong>EMPTY STRING</strong><br/>\nJPA 표준은 ''을 길이 0인 Empty String으로 정했지만, 데이터베이스에 따라 <code class=\"language-text\">NULL</code> 로 사용하는 데이터베이스도 있어 확인이 필요하다.</p>\n<p><strong>NULL 정의</strong></p>\n<ul>\n<li>조건을 만족하는 데이터가 하나도 없는 경우</li>\n<li><code class=\"language-text\">NULL</code> 은 알 수 없는 값이다. <code class=\"language-text\">NULL</code> 과의 모든 수학적 계산 결과는 <code class=\"language-text\">NULL</code> 이다.</li>\n<li><code class=\"language-text\">Null == Null</code> 은 알 수 없는 값이다.</li>\n<li><code class=\"language-text\">Null is Null</code> 은 참이다.</li>\n</ul>\n<h3>➰ 엔티티 직접 사용</h3>\n<p><strong>기본 키 값</strong><br/>\n객체 인스턴스는 참조 값으로 식별하고, 테이블 로우는 기본 키 값으로 식별한다.</p>\n<ul>\n<li>따라서 <strong>JPQL에서 엔티티 객체를 직접 사용</strong>하면 <strong>SQL에서는 해당 엔티티의 기본 키 값을 사용</strong>한다.</li>\n</ul>\n<p><strong>외래 키 값</strong><br/>\n특정 팀에 소속된 회원을 찾는 예제로 확인한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Team team = em.find(Team.class, 1L);\n\nString qlString = &quot;select m from Member m where m.team = :team&quot;;\nList resultList = em.createQuery(qlString)\n    .setParameter(&quot;team&quot;, team);\n    .getResultList();</code>\n        </deckgo-highlight-code>\n<ul>\n<li>기본 키 값이 1L인 팀 엔티티를 파라미터로 사용하고 있다.</li>\n<li><code class=\"language-text\">m.team</code> 은 현재 <code class=\"language-text\">team_id</code> 라는 외래 키와 매핑되어 있다.</li>\n</ul>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">select m.* from Member m where m.team_id = ?</code>\n        </deckgo-highlight-code>\n<p>엔티티 대신 식별자 값을 직접 사용할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String qlString = &quot;select m from Member m where m.team.id = :teamId&quot;;\nList resultList = em.createQuery(qlString)\n    .setParameter(&quot;teamId&quot;, 1L);\n    .getResultList();</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">m.team.id</code> 를 보면 <code class=\"language-text\">Member</code> 와 <code class=\"language-text\">Team</code> 간 묵시적 조인이 발생할 것 같지만, <code class=\"language-text\">MEMBER</code> 테이블이 외래 키를 가지고 있어 발생하지 않는다.</li>\n</ul>\n<blockquote>\n<p><code class=\"language-text\">m.team</code> 을 사용하든, <code class=\"language-text\">m.team.id</code> 를 사용하든 생성되는 SQL은 같다.</p>\n</blockquote>\n<h3>➰ Named 쿼리: 정적 쿼리</h3>\n<p>JPQL은 크게 동적 쿼리와 정적 쿼리로 나눌 수 있다.</p>\n<ul>\n<li>\n<p><strong>동적 쿼리</strong></p>\n<ul>\n<li>JPQL을 문자로 완성해서 직접 넘기는 것</li>\n<li>런타임에 특정 조건에 따라 동적으로 구성할 수 있다.</li>\n</ul>\n</li>\n<li>\n<p><strong>정적 쿼리</strong></p>\n<ul>\n<li>미리 정의한 쿼리에 이름을 부여해 필요할 때 사용하는 것, Named 쿼리라 한다.</li>\n<li>한 번 정의하면 변경할 수 없다.</li>\n</ul>\n</li>\n</ul>\n<p>Named 쿼리는 애플리케이션 로딩 시점에 JPQL 문법 체크 후 미리 파싱해둔다.</p>\n<ul>\n<li>오류를 빨리 확인할 수 있고, 사용하는 시점에는 파싱된 결과를 재사용하여 성능상 이점도 있다.</li>\n<li>정적 SQL을 생성하므로, 데이터베이스의 조회 성능 최적화에도 도움이 된다.</li>\n</ul>\n<p><strong>Named 쿼리를 어노테이션에 정의</strong><br/>\n<code class=\"language-text\">@NamedQuery</code> annotation을 사용한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\n@NamedQuery (\n  name = &quot;Member.findByUsername&quot;,\n  query = &quot;select m from Member m where m.username = :username&quot;)\npublic class Member {\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">name</code> 에 이름을 부여하고, <code class=\"language-text\">query</code> 에 사용할 쿼리를 입력한다.</li>\n<li>사용 시에는 <code class=\"language-text\">em.createNamedQuery()</code> 메소드에 Named 쿼리 이름을 입력하여 사용한다.</li>\n<li>여러 개의 쿼리를 사용하기 위해서는 <code class=\"language-text\">@NamedQueries</code> annotation을 사용할 수 있다.</li>\n</ul>\n<blockquote>\n<p>엔티티 이름을 쿼리 이름 앞에 붙여 영속성 유닛 단위로 관리되는 Named 쿼리의 충돌을 방지한다.</p>\n</blockquote>\n<p><code class=\"language-text\">@NamedQuery</code> annotation</p>\n<ul>\n<li><code class=\"language-text\">lockMode</code> : 쿼리 실행 시 락을 건다. (default: NONE)</li>\n<li><code class=\"language-text\">hints</code> : SQL 힌트가 아니라 JPA 구현체에게 제공하는 힌트다. </li>\n</ul>\n<p><strong>Named 쿼리를 XML에 정의</strong><br/>\nJPA에서 annotation으로 작성할 수 있는 것은 XML로도 작성할 수 있다. </p>\n<ul>\n<li>자바에서 멀티라인 문자를 다루는 것은 상당히 귀찮은데, XML을 사용하는 것이 현실적인 대안이 될 수 있다.</li>\n</ul>\n<deckgo-highlight-code language=\"xml\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">&lt;!-- META-INF/ormMember.xml --&gt;\n&lt;named-query name=&quot;Member.findByUsername&quot;&gt;\n  &lt;query&gt;&lt;CDATA[\n    select m\n    from Member m\n    where m.username = :username\n  ]&gt;&lt;/query&gt;\n&lt;/named-query&gt;\n\n&lt;named-query name=&quot;Member.count&quot;&gt;\n  &lt;query&gt;select count(m) from Member m&lt;/query&gt;\n&lt;/named-query&gt;</code>\n        </deckgo-highlight-code>\n<p>작성한 xml을 인식하도록 코드를 추가한다.</p>\n<deckgo-highlight-code language=\"xml\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">&lt;!-- META-INF/persistence.xml --&gt;\n&lt;persistence-unit name=&quot;jpabook&quot;&gt;\n  &lt;mapping-file&gt;META-INF/ormMember.xml&lt;/mapping-file&gt;\n  ...</code>\n        </deckgo-highlight-code>\n<blockquote>\n<p><code class=\"language-text\">META-INF/orm.xml</code> 은 기본 매핑 파일로 인식한다.</p>\n</blockquote>\n<p><strong>환경에 따른 설정</strong><br/>\nXML과 annotation에 같은 설정이 있다면 <strong>XML이 우선권</strong>을 가진다.</p>\n<hr>\n<h2>💫 Criteria</h2>\n<p>JPQL을 자바 코드로 작성하도록 도와주는 빌더 클래스 API이다.</p>\n<ul>\n<li>문자가 아닌 코드로 JPQL을 작성해 문법 오류를 컴파일 단계에서 확인할 수 있다.</li>\n<li>문자 기반의 JPQL보다 동적 쿼리를 안전하게 생성할 수 있다.</li>\n<li>코드가 복잡하고 장황해서 직관적인 이해가 어렵다는 단점이 있다.</li>\n</ul>\n<h3>➰ Criteria 기초</h3>\n<p>Criteria API는 <code class=\"language-text\">javax.persistence.criteria</code> 패키지에 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">CriteriaBuilder cb = em.getCriteriaBuilder();\n\nCriteriaQuery&lt;Member&gt; cq = cb.createQuery(Member.class); // 반환타입 지정\n\nRoot&lt;Member&gt; m = cq.from(Member.class); // FROM 절\ncq.select(m);\n\nTypedQuery&lt;Member&gt; query = em.createQuery(cq);\nList&lt;Member&gt; members = query.getResultList();</code>\n        </deckgo-highlight-code>\n<ul>\n<li>Criteria 쿼리 생성을 위해서는 Criteria 빌더를 얻어야 한다. EntityManager나 EntityManagerFactory에서 얻을 수 있다.</li>\n<li>Criteria 쿼리 빌더에서 Criteria 쿼리를 생성한다. 이때 반환 타입을 지정할 수 있다.</li>\n<li>FROM 절을 생성한다. 반환된 값은 별칭이고, 이를 조회의 시작점으로 잡는다.</li>\n</ul>\n<p>검색 조건과 정렬 조건을 추가한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">CriteriaBuilder cb = em.getCriteriaBuilder();\n\nCriteriaQuery&lt;Member&gt; cq = cb.createQuery(Member.class); \n\nRoot&lt;Member&gt; m = cq.from(Member.class); \n\nPredicate usernameEqual = cb.equal(m.get(&quot;username&quot;), &quot;회원1&quot;);\n\njavax.persistence.criteria.Order ageDesc = cb.desc(m.get(&quot;age&quot;));\n\ncq.select(m)\n    .where(usernameEqual)\n    .orderBy(ageDesc);\n\nList&lt;Member&gt; resultList = em.createQuery(cq).getResultList();</code>\n        </deckgo-highlight-code>\n<p><strong>쿼리 루트와 별칭</strong></p>\n<ul>\n<li>쿼리 루트는 조회의 시작점이다.</li>\n<li>별칭은 엔티티에만 부여할 수 있다.</li>\n</ul>\n<p><code class=\"language-text\">m.get(\"age\")</code> 메소드는 <code class=\"language-text\">age</code> 의 타입 정보를 모르기 때문에 <code class=\"language-text\">m.&lt;Integer>get(\"age\")</code> 와 같이 제네릭으로 반환 타입 정보를 명시해야 한다.(<code class=\"language-text\">String</code> 같은 문자 타입은 지정하지 않아도 된다.)</p>\n<h3>➰ Criteria 쿼리 생성</h3>\n<p><code class=\"language-text\">CriteriaBuilder.createQuery()</code> 메소드로 Criteria 쿼리를 생성해 사용한다.</p>\n<ul>\n<li>\n<p><code class=\"language-text\">CriteriaBuilder</code> interface를 보면, 쿼리 생성 시 파라미터로 쿼리 결과에 대한 반홭 타입을 지정할 수 있다.</p>\n<ul>\n<li>반환 타입을 지정했다면, <code class=\"language-text\">em.createQuery()</code> 에서 반환 타입을 지정하지 않아도 된다.</li>\n</ul>\n</li>\n<li>\n<p>반환 타입을 지정할 수 없거나, 반환 타입이 둘 이상이면 타입 명시 없이 <code class=\"language-text\">Object</code> 로 반환받는다.</p>\n<ul>\n<li>물론 반환 타입이 둘 이상미녀 <code class=\"language-text\">Object[]</code> 를 사용하는 것이 편리하다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ 조회</h3>\n<p><code class=\"language-text\">CriteriaQuery</code> interface 의 <code class=\"language-text\">select</code> , <code class=\"language-text\">multiselect</code> 메소드</p>\n<p><strong>조회 대상을 한 건, 여러 건 지정</strong></p>\n<ul>\n<li><code class=\"language-text\">select</code> 에 조회 대상을 하나만 지정하려면 <code class=\"language-text\">cq.select(m)</code> 과 같이 작성한다.</li>\n<li>\n<p>조회 대상을 여러 건 지정하려면 <code class=\"language-text\">cq.multiselect(m.get(\"username\"), m.get(\"age\"));</code> 과 같이 작성한다.</p>\n<ul>\n<li>여러 건 지정은 <code class=\"language-text\">cb.array</code> 사용도 가능하다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>DISTINCT</strong><br/>\n<code class=\"language-text\">select</code> , <code class=\"language-text\">multiselect</code> 다음에 <code class=\"language-text\">distinct(true)</code> 로 사용한다.</p>\n<p><strong>NEW, construct()</strong><br/>\nJPQL에서 <code class=\"language-text\">select new 생성자()</code> 구문을 Criteria에서는 <code class=\"language-text\">cb.construct(클래스 타입, ...)</code> 로 사용한다.</p>\n<p><strong>튜플</strong><br/>\nCriteria는 <code class=\"language-text\">Map</code> 과 비슷한 <strong>튜플</strong>이라는 특별한 반환 객체를 제공한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">CriteriaQuery&lt;Tuple&gt; cq = cb.createTupleQuery();\n\ncq.multiselect (\n  m.get(&quot;username&quot;).alias(&quot;username&quot;), // 튜플에서 사용할 별칭 지정\n  m.get(&quot;age&quot;).alias(&quot;age&quot;)\n);\n\nTypedQuery&lt;Tuple&gt; query = em.createQuery(cq);\nList&lt;Tuple&gt; resultList = query.getResultList();\nfor (Tuple tuple : resultList) {\n  // 튜플 별칭으로 조회\n  String username = tuple.get(&quot;username&quot;, String.class);\n  Integer age = tuple.age(&quot;age&quot;, Integer.class);\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>튜플을 사용하려면 <code class=\"language-text\">cb.createTupleQuery</code> 또는 <code class=\"language-text\">cb.createQuery(Tuple.class)</code> 로 Criteria를 생성한다.</li>\n<li>튜플은 튜플의 검색 키로 사용할 <strong>튜플 전용 별칭을 필수로 할당</strong>해야 한다.</li>\n<li>선언해둔 튜플 별칭으로 데이터를 조회한다.</li>\n<li>튜플은 이름 기반으로, 순서 기반의 <code class=\"language-text\">Object[]</code> 보다 안전하다. </li>\n<li><code class=\"language-text\">tuple.getElements()</code> 같은 메소드로 현재 튜플의 별칭과 자바 타입도 조회할 수 있다. </li>\n</ul>\n<h3>➰ 집합</h3>\n<p><strong>GROUP BY</strong></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">cq.groupBy(m.get(&quot;team&quot;).get(&quot;name&quot;))</code>\n        </deckgo-highlight-code>\n<ul>\n<li>JPQL의 <code class=\"language-text\">group by m.team.name</code> 과 같다.</li>\n</ul>\n<p><strong>HAVING</strong></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">cq.multiselect(m.get(&quot;team&quot;).get(&quot;name&quot;), maxAge, minAge)\n    .groupBy(m.get(&quot;team&quot;).get(&quot;name&quot;))\n    .having(cb.gt(minAge, 10));</code>\n        </deckgo-highlight-code>\n<ul>\n<li>JPQL의 <code class=\"language-text\">having min(m.age) > 10</code> 과 같다.</li>\n</ul>\n<h3>➰ 정렬</h3>\n<p><code class=\"language-text\">cb.desc()...</code> 또는 <code class=\"language-text\">cb.asc(...)</code> 로 생성할 수 있다.</p>\n<h3>➰ 조인</h3>\n<p><code class=\"language-text\">join()</code> 메소드와 <code class=\"language-text\">JoinType</code> 클래스를 사용한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public enum JoinType {\n\n  INNER, (default)\n  LEFT,\n  RIGHT\n\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Root&lt;Member&gt; m = cq.from(Member.class);\nJoin&lt;Member, Team&gt; t = m.join(&quot;team&quot;, JoinType.INNER); // 내부 조인 설정\n\ncq.multiselect(m, t);\n  .where(cb.equal(t.get(&quot;name&quot;), &quot;팀A&quot;));</code>\n        </deckgo-highlight-code>\n<p>FETCH JOIN은 다음과 같이 설정한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Root&lt;Member&gt; m = cq.from(Member.class);\nm.fetch(&quot;team&quot;, JoinType.LEFT);\n\ncq.select(m);</code>\n        </deckgo-highlight-code>\n<h3>➰ 서브 쿼리</h3>\n<p><strong>간단한 서브 쿼리</strong><br/>\n메인 쿼리와 서브 쿼리 간 관련이 없는 서브 쿼리를 말한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">CriteriaQuery&lt;Member&gt; mainQuery = cb.createQuery(Member.class);\n\nSubquery&lt;Double&gt; subQuery = mainQuery.subquery(Double.class);\nRoot&lt;Member&gt; m2 = subQuery.from(Member.class);\nsubQuery.select(cb.avg(m2.&lt;Integer&gt;get(&quot;age&quot;)));\n\nRoot&lt;Member&gt; m = mainQuery.from(Member.class);\nmainQuery.select(m)\n  .where(cb.ge(m.&lt;Integer&gt;get(&quot;age&quot;), subQuery));</code>\n        </deckgo-highlight-code>\n<ol>\n<li>서브 쿼리는 <code class=\"language-text\">mainQuery.subquery()</code> 로 생성한다.</li>\n<li>메인 쿼리는 <code class=\"language-text\">where(..., subQuery)</code> 에서 생성한 서브 쿼리를 사용한다.</li>\n</ol>\n<p><strong>상호 관련 서브 쿼리</strong><br/>\n메인 쿼리와 서브 쿼리 간 관련이 있는 경우이다.</p>\n<ul>\n<li>\n<p>서브 쿼리에서 메인 쿼리의 정보를 사용하려면 메인 쿼리에서 사용한 별칭을 얻어야 한다.</p>\n<ul>\n<li>메인 쿼리의 <code class=\"language-text\">Root</code> 나 <code class=\"language-text\">Join</code> 을 통해 생성된 별칭을 받아 사용한다. 이때 <code class=\"language-text\">Root&lt;Member> subM = subQuery.correlate(m);</code> 을 사용해 메인 쿼리의 별칭을 가져올 수 있다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ IN 식</h3>\n<p>Criteria 빌더에서 <code class=\"language-text\">in(...)</code> 메소드를 사용한다.</p>\n<h3>➰ CASE 식</h3>\n<p><code class=\"language-text\">selectCase()</code> 메소드와 <code class=\"language-text\">when()</code> , <code class=\"language-text\">otherwise()</code> 메소드를 사용한다.</p>\n<h3>➰ 파라미터 정의</h3>\n<p>JPQL에서 <code class=\"language-text\">:PARAM1</code> 처럼 파라미터를 정의했듯 정의할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">cq.select(m)\n    .where(cb.equal(m.get(&quot;username&quot;), cb.parameter(String.class, &quot;usernameParam&quot;))); // 파라미터 정의\n\nList&lt;Member&gt; resultList = em.createQuery(cq)\n    .setParameter(&quot;usernameParam&quot;, &quot;회원1&quot;) // 바인딩\n    .getResultList();</code>\n        </deckgo-highlight-code>\n<h3>➰ 네이티브 함수 호출</h3>\n<p>네이티브 SQL 함수 호출을 위해서는 <code class=\"language-text\">cb.function(...)</code> 메소드를 사용하면 된다.</p>\n<h3>➰ 동적 쿼리</h3>\n<p>다양한 검색 조건에 따라 실행 시점에 쿼리를 생성하는 것을 동적 쿼리라 한다.</p>\n<ul>\n<li>코드 기반인 Criteria로 작성하는 것이 편리하다.</li>\n<li>공백이나 <code class=\"language-text\">where</code> , <code class=\"language-text\">and</code> 의 위치로 인한 에러가 발생하지는 않는다.</li>\n<li>하지만 장황하고 복잡하다는 단점이 크다.</li>\n</ul>\n<h3>➰ 함수 정리</h3>\n<p>Criteria는 JPQL 빌더 역할을 해 JPQL 함수를 코드로 지원한다.</p>\n<ul>\n<li>Expression의 메소드(<code class=\"language-text\">isNull()</code> , <code class=\"language-text\">isNotNull()</code> , <code class=\"language-text\">in()</code>)</li>\n<li>조건 함수</li>\n<li>스칼라와 기타 함수</li>\n<li>집합 함수</li>\n<li>분기 함수</li>\n</ul>\n<h3>➰ Criteria 메타 모델 API</h3>\n<p>코드 기반의 Criteria는 컴파일 시점에 오류를 발견할 수 있다.</p>\n<ul>\n<li>\n<p>하지만 <code class=\"language-text\">m.get(\"age\")</code> 에서 <code class=\"language-text\">age</code> 는 문자다. 이를 <code class=\"language-text\">aggeadf</code> 라고 적어도 컴파일 시점에 에러를 발견하지 못한다.</p>\n<ul>\n<li>따라서 완전한 코드 기반이라 할 수 없다.</li>\n</ul>\n</li>\n<li>이런 부분까지 코드로 작성하기 위해서는 메타 모델 API를 사용하면 된다. 먼저 메타 모델 클래스를 생성한다.</li>\n</ul>\n<p><strong>메타 모델 API 적용 전</strong></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">cq.select(m)\n    .where(cb.gt(m.&lt;Integer&gt;get(&quot;username&quot;), 20))\n    .orderBy(cb.desc(m.get(&quot;age&quot;)));</code>\n        </deckgo-highlight-code>\n<p><strong>메타 모델 API 적용 후</strong></p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">cq.select(m)\n    .where(cb.gt(m.get(Member_.age),20))\n    .orderBy(cb.desc(m.get(Member_.age)));</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>문자 기반에서 정적인 코드 기반으로 변경되었다. </p>\n<ul>\n<li>이를 위해서는 <code class=\"language-text\">Member_</code> 클래스가 필요한데, 이를 <strong>메타 모델 클래스</strong>라 한다.</li>\n</ul>\n</li>\n<li>\n<p>메타 모델 클래스는 해당 엔티티를 기반이고, 코드 자동 생성기가 <code class=\"language-text\">엔티티명_.java</code> 모양의 메타 모델 클래스를 생성해준다.</p>\n<ul>\n<li>Hibernate 구현체는 <code class=\"language-text\">org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor</code> 를 사용한다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>코드 생성기 설정</strong><br/>\n보통 메이븐이나 엔트, 그래들 같은 빌드 도구를 사용해 코드 생성기를 실행한다.</p>\n<ul>\n<li>메이븐을 기준으로, <code class=\"language-text\">hibernate-jpamodelgen</code> 과 <code class=\"language-text\">maven-compiler-plugin</code> 설정을 추가한다.</li>\n<li><code class=\"language-text\">mvn compile</code> 명령어를 사용해 메타 모델 클래스를 생성한다.</li>\n</ul>\n<hr>\n<h2>💫 QueryDSL</h2>\n<p>JPQ Criteria는 문자가 아닌 코드로 JPQL를 작성하여 문법 오류를 컴파일 단계에서 잡을 수 있고, IDE 자동완성 기능의 도움을 받을 수 있는 등 여러 장점이 있지만, 복잡하고 장황하다는 큰 단점이 존재한다. </p>\n<p>쿼리를 문자가 아닌 코드로 작성해도, 쉽고 간결하며 그 모양도 쿼리와 비슷하게 개발할 수 있는 프로젝트가 바로 QueryDSL이다.</p>\n<ul>\n<li>JPQL 빌더 역할을 하는데, JPA Criteria를 대체할 수 있다.</li>\n<li>쿼리 즉 데이터를 조회하는데 기능이 특화되어 있다.</li>\n</ul>\n<h3>➰ QueryDSL 설정</h3>\n<p>gradle 기준!</p>\n<p><strong>📌 필요 라이브러리</strong><br/></p>\n<deckgo-highlight-code language=\"xml\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">implementation &#39;org.springframework.boot:spring-boot-starter-data-jpa&#39;\nimplementation &#39;com.querydsl:querydsl-jpa&#39;\nimplementation &#39;com.querydsl:querydsl-apt&#39;</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">querydsl-jpa</code> : QueryDSL JPA 라이브러리</li>\n<li><code class=\"language-text\">querydsl-apt</code> : 쿼리 타입(Q)을 생성할 때 필요한 라이브러리</li>\n</ul>\n<p><strong>📌 환경설정</strong><br/>\nQueryDSL을 사용하기 위해서는 Criteria의 메타 모델처럼 엔티티를 기반으로 쿼리 타입이라는 쿼리용 클래스를 생성해야 한다. (Q클래스라고도 한다.)</p>\n<ul>\n<li><code class=\"language-text\">build.gradle</code> 에 쿼리 타입을 생성할 위치를 지정하고, <code class=\"language-text\">Gradle</code> -> <code class=\"language-text\">build</code> 하면 쿼리 타입이 해당 경로에 생성된다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// queryDSL이 생성하는 QClass 경로 설정\ndef querydslDir = &quot;$buildDir/generated/querydsl&quot;\n\nquerydsl {\n\tlibrary = &quot;com.querydsl:querydsl-apt&quot;\n\tjpa = true\n\tquerydslSourcesDir = querydslDir\n}\n\nsourceSets {\n\tmain.java.srcDir querydslDir\n}\n\nconfigurations {\n\tquerydsl.extendsFrom compileClasspath\n}\n\ncompileQuerydsl {\n\toptions.annotationProcessorPath = configurations.querydsl\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">import com.querydsl.jpa.impl.JPAQueryFactory;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\n\nimport javax.persistence.EntityManager;\nimport javax.persistence.PersistenceContext;\n\n@Configuration\npublic class QuerydslConfig {\n\n    @PersistenceContext\n    private EntityManager em;\n\n    @Bean\n    public JPAQueryFactory jpaQueryFactory() {\n        return new JPAQueryFactory(em);\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>그리고 엔티티 매니저를 주입한 JPAQueryFactory를 Bean으로 등록하여 프로젝트 전역에서 QueryDSL을 작성할 수 있게 한다.</li>\n</ul>\n<h3>➰ 시작</h3>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public void queryDSL() {\n\n  ...\n  \n  EntityManager em = emf.createEntityManager();\n\n  JPAQuery query = new JPAQuery(em);\n  QMember qMember = new QMember(&quot;m&quot;);\n  List&lt;Member&gt; members = \n      query.from(qMember)\n           .where(qMember.name.eq(&quot;회원1&quot;))\n           .orderBy(qMember.name.desc())\n           .list(qMember);\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>QueryDSL을 사용하기 위해서는 <code class=\"language-text\">JPAQuery</code> 객체를 생성해야 하는데, 이때 엔티티 매니저를 생성자에 넘겨준다.</li>\n<li>\n<p>그리고 사용할 쿼리 타입을 생성하는데, 생성자에는 별칭을 넘겨준다.</p>\n<ul>\n<li>이 별칭을 JPQL에서 별칭으로 사용한다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>📌 기본 Q 생성</strong><br/>\n쿼리 타입은 사용하기 편리하도록 기본 인스턴스를 보관하고 있다.</p>\n<ul>\n<li>하지만 같은 엔티티를 조인하거나 같은 엔티티를 서브 쿼리에 사용하면 같은 별칭이 사용되므로, 이때는 별칭을 직접 지정해서 사용해야 한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class QMember extends EntityPathBase&lt;Member&gt; {\n\n  public static final QMember member = new QMember(&quot;member1&quot;);\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">QMember qMember = new QMember(&quot;m&quot;); // 직접 지정\nQMember qMember = QMember.member;   // 기본 인스턴스 사용</code>\n        </deckgo-highlight-code>\n<ul>\n<li>쿼리 타입은 위와 같이 사용할 수 있다.</li>\n<li>기본 인스턴스를 사용하면 <code class=\"language-text\">import static</code> 을 사용해 더 간결한 코드를 작성할 수 있다.</li>\n</ul>\n<h3>➰ 검색 조건 쿼리</h3>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">JPAQuery query = new JPAQuery(em);\nQItem item = QItem.item;\nList&lt;Item&gt; list = query.from(item)\n    .where(item.name.eq(&quot;좋은 상품&quot;).and(item.price.gt(20000)))\n    .list(item);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>QueryDSL의 <code class=\"language-text\">where</code> 절에는 <code class=\"language-text\">and</code> 나 <code class=\"language-text\">or</code> 을 사용할 수 있다. 또한 여러 검색 조건을 사용할 수 있다.</li>\n</ul>\n<h3>➰ 결과 조회</h3>\n<p>쿼리 작성이 끝나고 결과 조회 메소드를 호출하면 실제 데이터베이스를 조회한다. </p>\n<ul>\n<li>보통 <code class=\"language-text\">uniqueResult()</code> 나 <code class=\"language-text\">list()</code> 를 사용하고 파라미터로 프로젝션 대상을 넘겨준다.</li>\n<li>결과 조회 API는 <code class=\"language-text\">com.mysema.query.Projectable</code> 에 정의되어 있다.</li>\n</ul>\n<p><strong><code class=\"language-text\">uniqueResult()</code></strong></p>\n<ul>\n<li>조회 결과가 한 건일 때 사용한다. </li>\n<li>조회 결과가 없으면 <code class=\"language-text\">null</code> 을 반환하고 결과가 하나 이상이면 <code class=\"language-text\">NonUniqueResultException</code> 예외가 발생한다.</li>\n</ul>\n<p><strong><code class=\"language-text\">singleResult()</code></strong></p>\n<ul>\n<li><code class=\"language-text\">uniqueResult()</code> 와 같지만 결과가 하나 이상이면 처음 데이터를 반환한다.</li>\n</ul>\n<p><strong><code class=\"language-text\">list()</code></strong> </p>\n<ul>\n<li>결과가 하나 이상일 때 사용한다.</li>\n<li>결과가 없으면 빈 컬렉션을 반환한다.</li>\n</ul>\n<h3>➰ 페이징과 정렬</h3>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">QItem item = QItem.item;\n\nquery.from(item)\n    .where(item.price.gt(20000))\n    .orderBy(item.price.desc(), item.stockQuantity.asc())\n    .offset(10).limit(20)\n    .list(item);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>정렬은 <code class=\"language-text\">orderBy()</code> ,<code class=\"language-text\">asc()</code> , <code class=\"language-text\">desc()</code> 을 사용한다.</li>\n<li>\n<p>페이징은 <code class=\"language-text\">offset</code> , <code class=\"language-text\">limit</code> 를 사용한다.</p>\n<ul>\n<li><code class=\"language-text\">restrict()</code> 메소드에 <code class=\"language-text\">new QueryModifiers(20L, 10L)</code> 를 파라미터로 사용해도 된다. </li>\n<li>파라미터의 <code class=\"language-text\">20L</code> 과 <code class=\"language-text\">10L</code> 은 각각 <strong>limit</strong>, <strong>offset</strong>을 의미한다.</li>\n</ul>\n</li>\n</ul>\n<p>실제 페이징 처리를 위해서는 <strong>검색된 전체 데이터 수</strong>를 알아야 한다.</p>\n<ul>\n<li>\n<p>이땐 <code class=\"language-text\">list()</code> 대신 <code class=\"language-text\">listResult()</code> 를 사용한다.</p>\n<ul>\n<li>전체 데이터 조회를 위한 <code class=\"language-text\">count</code> 쿼리를 한 번 더 실행한다.</li>\n<li>그리고 <code class=\"language-text\">SearchResults</code> 를 반환하는데, 이 객체에서 전체 데이터 수(<code class=\"language-text\">getTotal()</code>)를 조회할 수 있다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ 그룹</h3>\n<p><code class=\"language-text\">groupBy</code> 를 사용하고 그룹화된 결과를 제한하려면 <code class=\"language-text\">having</code> 을 사용한다.</p>\n<h3>➰ 조인</h3>\n<p><code class=\"language-text\">innerJoin(join)</code> , <code class=\"language-text\">leftJoin</code> , <code class=\"language-text\">rightJoin</code> , <code class=\"language-text\">fullJoin</code> 을 사용할 수 있고, 추가로 JPQL의 <code class=\"language-text\">on</code> 과 성능 최적화를 위한 <code class=\"language-text\">fetch</code> 조인도 사용할 수 있다.</p>\n<ul>\n<li>기본 문법은 첫 번째 파라미터에 조인 대상을 지정하고, 두 번째 파라미터에 별칭으로 사용할 쿼리 타입을 지정한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 가장 기본적인 조인 방법\n\nQOrder order = QOrder.order;\nQMember member = QMember.member;\nQOrderItem orderItem = QOrderItem.orderItem;\n\nquery.from(order)\n    .join(order.member, member)\n    .leftJoin(order.orderItems, orderItem)\n    .list(order);</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 조인에 on을 사용한 예\n\n...\n\nquery.from(order)\n    .leftJoin(order.orderItems, orderItem)\n    .on(orderItem.count.gt(2))\n    .list(order);</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 페치 조인을 사용한 예\n\n...\n\nquery.from(order)\n    .innerJoin(order.member, member).fetch()\n    .leftJoin(order.orderItems, orderItem).fetch()\n    .list(order);</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 세타 조인을 사용한 예\n\nQOrder order = QOrder.order;\nQMember member = QMember.member;\n\nquery.from(order, member)\n    .where(order.member.eq(member))\n    .list(order);</code>\n        </deckgo-highlight-code>\n<h3>➰ 서브 쿼리</h3>\n<p>서브 쿼리는 <code class=\"language-text\">JPASubQuery</code> 를 생성해 사용한다.</p>\n<ul>\n<li>결과가 하나면 <code class=\"language-text\">unique()</code> , 여러 건이면 <code class=\"language-text\">list()</code> 를 사용한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 서브 쿼리 - 한 건\nQItem item = QItem.item;\nQItem itemSub = new QItem(&quot;itemSub&quot;);\n\nquery.from(item)\n    .where(item.price.eq(\n      new JPASubQuery().from(itemSub).unique(itemSub.price.max())\n    ))\n    .list(item);</code>\n        </deckgo-highlight-code>\n<h3>➰ 프로젝션과 결과 반환</h3>\n<p><strong>📌 프로젝션 대상이 하나</strong></p>\n<ul>\n<li>프로젝션 대상이 하나면 해당 타입으로 반환한다.</li>\n</ul>\n<p><strong>📌 여러 컬럼 반환과 튜플</strong></p>\n<ul>\n<li>\n<p>프로젝션 대상으로 여러 필드를 선택하면, QueryDSL은 기본으로 <strong>Tuple</strong>을 사용한다. </p>\n<ul>\n<li><code class=\"language-text\">List&lt;Tuple></code> 로 반환받는다.</li>\n<li>조회 결과는 <code class=\"language-text\">tuple.get()</code> 메소드에 조회한 쿼리 타입을 지정하면 된다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>📌 빈 생성</strong></p>\n<ul>\n<li>\n<p>쿼리 결과를 엔티티가 아닌 특정 객체로 받고 싶다면, <strong>빈 생성(Bean population) 기능</strong>을 사용한다.</p>\n<ul>\n<li>프로퍼티 접근</li>\n<li>필드 직접 접근</li>\n<li>생성자 사용</li>\n</ul>\n</li>\n<li>원하는 방법 지정을 위해서는 <code class=\"language-text\">com.mysema.query.types.Projections</code> 를 사용하면 된다.</li>\n</ul>\n<p>먼저 <strong>프로퍼티 접근(<code class=\"language-text\">Setter</code>) 방식</strong>이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">QItem item = QItem.item;\nList&lt;ItemDTO&gt; result = query.from(item).list(\n  Projections.bean(ItemDTO.class, item.name.as(&quot;username&quot;), item.price));</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">Projections.bean()</code> 은 수정자(<code class=\"language-text\">Setter</code>)를 사용해 값을 채운다.</li>\n<li>쿼리 결과와 매핑할 프로퍼티 이름이 다르다면 <code class=\"language-text\">as</code> 를 사용해서 별칭을 사용하면 된다.</li>\n</ul>\n<p>먼저 <strong>필드 직접 접근 방식</strong>이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">QItem item = QItem.item;\nList&lt;ItemDTO&gt; result = query.from(item).list(\n  Projections.fields(ItemDTO.class, item.name.as(&quot;username&quot;), item.price));</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">Projections.fields()</code> 를 사용해 필드에 직접 접근해 값을 채운다.</li>\n<li>필드를 <code class=\"language-text\">private</code> 로 설정해도 동작한다.</li>\n</ul>\n<p>먼저 <strong>생성자 방식</strong>이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">QItem item = QItem.item;\nList&lt;ItemDTO&gt; result = query.from(item).list(\n  Projections.constructor(ItemDTO.class, item.name, item.price));</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">Projections.constructor()</code> 는 생성자를 사용한다. </li>\n<li>지정한 프로젝션과 파라미터 순서가 같은 생성자가 필수적이다.</li>\n</ul>\n<h3>➰ 수정, 삭제 배치 쿼리</h3>\n<p>JPQL 배치 쿼리와 같이 <strong>영속성 컨텍스트를 무시하고 데이터베이스를 직접 쿼리</strong>한다는 점을 유의해야 한다.</p>\n<ul>\n<li>수정 배치 쿼리는 <code class=\"language-text\">com.mysema.query.jpa.impl.JPAUpdateClause</code> 를 사용하고,</li>\n<li>삭제 배치 쿼리는 <code class=\"language-text\">com.mysema.query.jpa.impl.JPADeleteClause</code></li>\n</ul>\n<h3>➰ 동적 쿼리</h3>\n<p><code class=\"language-text\">com.mysema.query.BooleanBuilder</code> 를 사용하면 특정 조건에 따른 동적 쿼리를 편리하게 생성할 수 있다.</p>\n<ul>\n<li><code class=\"language-text\">BooleanBuilder.and()</code> 메소드로 쿼리를 붙여 작성할 수 있다.</li>\n</ul>\n<h3>➰ 메소드 위임</h3>\n<p>메소드 위임(Delegate methods) 기능으로 쿼리 타입에 검색 조건을 직접 정의할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class ItemExpression {\n\n  @QueryDelegate(Item.class)\n  public static BooleanExpression isExpensive(QItem item, Integer price) {\n    return item.price.gt(price);\n  }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>먼저 정적(<code class=\"language-text\">static</code>) 메소드를 만들고,</li>\n<li><code class=\"language-text\">@QueryDelegate</code> annotation에 속성으로 이 기능을 적용할 엔티티를 지정한다.</li>\n</ul>\n<hr>\n<h2>💫 네이티브 SQL</h2>\n<p>JPQL은 표준 SQL이 지원하는 대부분의 문법과 SQL 함수들을 지원하지만, 특정 데이터베이스에 종속적인 기능은 지원하지 않는다.</p>\n<ul>\n<li>특정 데이터베이스만 지원하는 함수, 문법, SQL 쿼리 힌트</li>\n<li>인라인 뷰(FROM 절에서 사용하는 서브 쿼리), UNION, INTERSECT</li>\n<li>Stored procedure</li>\n</ul>\n<p>하지만 때로는 특정 데이터베이스에 종속적인 기능이 필요하므로, 아래와 같이 JPA 구현체들은 다양한 방법을 지원한다.(JPA보다 더 다양한 방법 지원)</p>\n<ul>\n<li>\n<p>특정 데이터베이스만 사용하는 함수</p>\n<ul>\n<li>JPQL에서 네이티브 SQL 함수를 호출할 수 있다.</li>\n<li>Hibernate는 데이터베이스 방언에 각 데이터베이스에 종속적인 함수들을 정의했다. 또한 직접 정의할 수도 있다.</li>\n</ul>\n</li>\n<li>\n<p>특정 데이터베이스만 지원하는 SQL 쿼리 힌트</p>\n<ul>\n<li>Hibernate를 포함한 몇몇 JPA 구현체들이 지원한다.</li>\n</ul>\n</li>\n<li>\n<p>인라인 뷰(FROM절에서 사용하는 서브 쿼리), UNION, INTERSECT</p>\n<ul>\n<li>일부 JPA 구현체들이 지원한다.</li>\n</ul>\n</li>\n<li>\n<p>Stored procedure</p>\n<ul>\n<li>JPQL에서 호출할 수 있다.</li>\n</ul>\n</li>\n<li>\n<p>특정 데이터베이스만 지원하는 문법</p>\n<ul>\n<li>너무 종속적인 SQL 문법은 지원하지 않아 네이티브 SQL을 사용해야 한다.</li>\n</ul>\n</li>\n</ul>\n<p>JPQL을 사용할 수 없을 때 JPA는 SQL을 직접 사용할 수 있는 기능을 제공하는데 이를 네이티브 SQL이라 한다.</p>\n<ul>\n<li>JPQL을 사용하면 JPA가 SQL을 생성한다.</li>\n</ul>\n<p><strong>📌 JPA가 지원하는 네이티브 SQL과 JDBC API를 직접 사용하는 것의 차이</strong></p>\n<ul>\n<li>네이티브 SQL을 사용하면 엔티티를 조회할 수 있고,</li>\n<li>JPA가 지원하는 영속성 컨텍스트의 기능을 그대로 사용할 수 있다.</li>\n</ul>\n<h3>➰ 네이티브 SQL 사용</h3>\n<p>네이티브 쿼리 API는 다음 3가지가 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 결과 타입 정의\npublic Query createNativeQuery(String sqlString, Class resultClass);\n\n// 결과 타입을 정의할 수 없는 경우\npublic Query createNativeQuery(String sqlString);\n\n// 결과 매핑 사용\npublic Query createNativeQuery(String sqlString, String resultSetMapping);</code>\n        </deckgo-highlight-code>\n<p><strong>📌 엔티티 조회</strong><br/>\n네이티브 SQL은 <code class=\"language-text\">em.createNativeQuery()</code> 를 사용한다. </p>\n<ul>\n<li>첫 번째 파라미터는 네이티브 SQL을 입력하고,</li>\n<li>두 번째 파라미터는 조회할 엔티티 클래스의 타입을 입력한다.</li>\n</ul>\n<blockquote>\n<p>JPQL과 흡사하지만 실제 데이터베이스 SQL을 사용한다는 것과, 위치기반 파라미터만 지원한다는 차이가 있다.</p>\n</blockquote>\n<p><strong>\"가장 중요한 점은 네이티브 SQL로 SQL만 직접 사용할 뿐이지 나머지는 JPQL을 사용할 떄와 같다. 조회한 엔티티도 영속성 컨텍스트에서 관리된다.\"</strong></p>\n<p><strong>📌 값 조회</strong><br/>\n값으로만 조회하는 경우 <code class=\"language-text\">em.createNativeQuery()</code> 의 두 번째 파라미터를 사용하지 않으면 된다.</p>\n<ul>\n<li>조회한 값들은 <code class=\"language-text\">Object[]</code> 에 담아서 반환된다.</li>\n<li>스칼라 값들을 조회했으므로 영속성 컨텍스트에서 관리되지 않는다.</li>\n</ul>\n<p><strong>📌 결과 매핑 사용</strong><br/>\n엔티티와 스칼라 값을 함께 조회하는 경우처럼 <strong>매핑이 복잡</strong>해지면, <code class=\"language-text\">@SqlResultSetMapping</code> 을 정의해서 결과 매핑을 사용해야 한다.</p>\n<ul>\n<li><code class=\"language-text\">em.createNativeQuery()</code> 의 두 번째 파라미터에 정의한 결과 매핑 정보의 이름을 사용한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 결과 매핑 정의\n@Entity\n@SqlResultSetMapping(name = &quot;memberWithOrderCount&quot;,\n    entities = {@EntityResult(entityClass = Member.class)},\n    columns = {@ColumnResult(name = &quot;ORDER_COUNT&quot;)}\n)\npublic class Member {...}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>회원 엔티티와 <code class=\"language-text\">ORDER_COUNT</code> 컬럼을 매핑했다.</li>\n<li>여러 엔티티와 컬럼들을 매핑할 수 있다.</li>\n</ul>\n<p><strong>📌 결과 매핑 annotation</strong><br/></p>\n<ul>\n<li>\n<p><code class=\"language-text\">@SqlResultSetMapping</code> 속성</p>\n<ul>\n<li>name : 결과 매핑 이름</li>\n<li>entities : <code class=\"language-text\">@EntityResult</code> 를 사용해서 엔티티를 결과로 매핑한다.</li>\n<li>columns : <code class=\"language-text\">@ColumnResult</code> 를 사용해서 컬럼을 결과로 매핑한다.</li>\n</ul>\n</li>\n<li>\n<p><code class=\"language-text\">@EntityResult</code> 속성</p>\n<ul>\n<li>entityClass : 결과로 사용할 엔티티 클래스를 지정한다.</li>\n<li>fields : <code class=\"language-text\">@FieldResult</code> 를 사용해서 결과 컬럼을 필드와 매핑한다.</li>\n<li>discriminatorColumn : 엔티티의 인스턴스 타입을 구분하는 필드(상속에서 사용)</li>\n</ul>\n</li>\n<li>\n<p><code class=\"language-text\">@FieldResult</code> 속성</p>\n<ul>\n<li>name : 결과를 받을 필드명</li>\n<li>column : 결과 컬럼명</li>\n</ul>\n</li>\n<li>\n<p><code class=\"language-text\">@ColumnResult</code> 속성</p>\n<ul>\n<li>name : 결과 컬럼명</li>\n</ul>\n</li>\n</ul>\n<h3>➰ Named 네이티브 SQL</h3>\n<p>JPQL처럼 Named 네이티브 SQL을 사용해서 정적 SQL을 작성할 수 있다.</p>\n<ul>\n<li>이때 <code class=\"language-text\">@NamedNativeQuery</code> annotation으로 Named 네이티브 SQL을 등록한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">TypedQuery&lt;Member&gt; nativeQuery = \n    em.createNamedQuery(&quot;Member.memberSQL&quot;, Member.class)\n        .setParameter(1, 20);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>JPQL Named 쿼리와 같은 <code class=\"language-text\">createNamedQuery</code> 메소드를 사용한다. 따라서 <code class=\"language-text\">TypeQuery</code> 를 사용할 수 있다.</li>\n<li>이후 Named 네이티브 쿼리에서 <code class=\"language-text\">resultSetMapping</code> 속성을 사용해서 조회 결과를 매핑할 대상을 지정할 수 있다.</li>\n</ul>\n<p><strong>📌 @NamedNativeQuery</strong><br/></p>\n<ul>\n<li>name : Named 쿼리 이름 (필수)</li>\n<li>query : SQL 쿼리 (필수)</li>\n<li>hints : 벤더 종속적인 힌트</li>\n<li>resultClass : 결과 클래스</li>\n<li>resultSetMapping : 결과 매핑 사용</li>\n</ul>\n<h3>➰ 네이티브 SQL XML에 정의</h3>\n<p>XML에 정의 시, </p>\n<ol>\n<li><code class=\"language-text\">&lt;named-native-query></code> 를 먼저 정의하고,</li>\n<li><code class=\"language-text\">&lt;sql-result-set-mapping></code> 을 정의해야 한다.</li>\n</ol>\n<h3>➰ 네이티브 SQL 정리</h3>\n<p>네이티브 SQL도 JPQL을 사용할 때와 마찬가지로 <code class=\"language-text\">Query</code> , <code class=\"language-text\">TypeQuery</code>(Named 네이티브 쿼리의 경우만!)를 반환한다.</p>\n<ul>\n<li>따라서 <strong>JPQL API를 그대로 사용</strong>할 수 있다.</li>\n</ul>\n<p>네이티브 SQL은 JPQL이 자동 생성하는 SQL을 수동으로 직접 정의하는 것이다.</p>\n<ul>\n<li>따라서 <strong>JPA가 제공하는 기능 대부분을 그대로 사용</strong>할 수 있다.</li>\n</ul>\n<h3>➰ 스토어드 프로시저</h3>\n<p>JPQ 2.1부터 지원한다.</p>\n<p><strong>📌 스토어드 프로시저 사용</strong><br/>\n입력 값을 두 배로 증가시켜 주는 스토어드 프로시저가 있다.</p>\n<ul>\n<li>첫 번째 파라미터로 값을 입력받고, 두 번째 파라미터로 결과를 반환한다.</li>\n</ul>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">DELIMITER //\n\nCREATE PROCEDURE proc_multiply (INOUT inParam INT, INOUT outParam INT)\nBEGIN\n  SET outParam = inParam * 2;\nEND //</code>\n        </deckgo-highlight-code>\n<p>JPA로 이 스토어드 프로시저를 호출하기 위해서는,</p>\n<ul>\n<li><code class=\"language-text\">em.createStoredProcedureQuery()</code> 메소드에 사용할 프로시저의 이름을 명시한다.</li>\n<li>\n<p>그리고 <code class=\"language-text\">registerStoredProcedureParameter()</code> 메소드를 사용해 프로시저에서 사용할 파라미터를 순서, 타입, 파라미터 모드 순으로 정의한다.</p>\n<ul>\n<li>순서 대신에 이름을 사용할 수도 있다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>📌 Named 스토어드 프로시저 사용</strong><br/>\n스토어드 프로시저 쿼리에 이름을 부여해서 사용하는 것을 말한다.</p>\n<ul>\n<li><code class=\"language-text\">@NamedStoredProcedureQuery</code> 로 정의하고, <code class=\"language-text\">name</code> 속성으로 이름을 부여하면 된다.</li>\n<li><code class=\"language-text\">procedureName</code> 에 실제 호출할 프로시저의 이름을 명시하고,</li>\n<li><code class=\"language-text\">@StoredProcedureParameter</code> 를 사용해 파라미터 정보를 정의하면 된다.</li>\n</ul>\n<hr>\n<h2>💫 객체지향 쿼리 심화</h2>\n<p>한 번에 여러 데이터를 수정할 수 있는 \"벌크 연산\"과 JPQL과 영속성 컨텍스트에 대해 다룬다. 그리고 JPQL과 플러시 모드를 다룬다.</p>\n<h3>➰ 벌크 연산</h3>\n<p>엔티티를 수정하려면 영속성 컨텍스트의 변경 감지 기능이나 병합을 사용하고, 삭제하려면 <code class=\"language-text\">em.remove()</code> 메소드를 사용한다.</p>\n<ul>\n<li>하지만 엄청나게 많은 엔티티를 처리하기에는 많은 시간 비용이 든다.</li>\n<li>이럴 때 사용하는 것이 <strong>벌크 연산</strong>이다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// UPDATE 벌크 연산\nString qlString = \n    &quot;update Product p &quot; + \n    &quot;set p.price = p.price * 1.1 &quot; +\n    &quot;where p.stockAmount &gt; :stockAmount&quot;;\n\nint resultCount = em.createQuery(qlString)\n                    .setParameter(&quot;stockAmount&quot;, 10)\n                    .executeUpdate();</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>벌크 연산은 <code class=\"language-text\">executeUpdate()</code> 메소드를 사용한다.</p>\n<ul>\n<li>벌크 연산으로 영향 받은 엔티티의 건수를 반환한다.</li>\n</ul>\n</li>\n<li>삭제 또한 같은 메소드를 사용한다.</li>\n</ul>\n<blockquote>\n<p>JPA 표준은 아니지만 Hibernate는 INSERT 벌크 연산도 지원한다.</p>\n</blockquote>\n<p><strong>📌 벌크 연산의 주의점</strong><br/>\n벌크 연산이 <strong>영속성 컨텍스트를 무시</strong>하고 <strong>데이터베이스에 직접 쿼리</strong>한다는 점에 주의해야 한다.</p>\n<ul>\n<li>따라서 <strong>영속성 컨텍스트에 있는 값과 데이터베이스에 있는 값이 다를 수 있다.</strong></li>\n<li>아래는 그 해결방법들이다.</li>\n</ul>\n<p><strong><code class=\"language-text\">em.refresh()</code> 사용</strong></p>\n<ul>\n<li>벌크 연산을 수행한 직후, 정확한 엔티티를 사용해야 한다면, <code class=\"language-text\">em.refresh()</code> 를 사용해 데이터베이스에서 해당 엔티티를 다시 조회하면 된다.</li>\n</ul>\n<p><strong>벌크 연산 먼저 실행</strong></p>\n<ul>\n<li>가장 실용적인 해결책이다. </li>\n<li>벌크 연산을 실행하고 난 뒤, 엔티티를 조회하여 두 값이 같도록 해준다.</li>\n</ul>\n<p><strong>벌크 연산 수행 후 영속성 컨텍스트 초기화</strong></p>\n<ul>\n<li>벌크 연산 수행 직후 영속성 컨텍스트를 초기화해서 남아 있는 엔티티를 제거하는 것도 좋은 방법이다.</li>\n<li>초기화한 후 엔티티를 조회하게 되면, 벌크 연산이 적용된 데이터베이스에서 엔티티를 조회할 것이다.</li>\n</ul>\n<h3>➰ 영속성 컨텍스트와 JPQL</h3>\n<p><strong>📌 퀴리 후 영속 상태인 것과 아닌 것</strong><br/>\nJPQL로 엔티티를 조회하면 영속성 컨텍스트에서 관리되지만 그렇지 않은 경우는 관리되지 않는다.</p>\n<blockquote>\n<p><strong>조회한 엔티티만 영속성 컨텍스트가 관리하고, 변경 감지가 발생한다.</strong></p>\n</blockquote>\n<p><strong>📌 JPQL로 조회한 엔티티와 영속성 컨텍스트</strong><br/>\n영속성 컨텍스트에 이미 특정 엔티티가 있는 경우에 동일한 엔티티를 JPQL로 조회한다면?</p>\n<ul>\n<li>\n<p>이미 영속성 컨텍스트에 동일한 엔티티가 있는 경우, <strong>JPQL로 데이터베이스에서 조회한 결과를 버리고, 영속성 컨텍스트에 있던 엔티티를 반환</strong>한다.</p>\n<ul>\n<li>이때 <strong>식별자 값을 사용해서 비교</strong>한다.</li>\n</ul>\n</li>\n</ul>\n<p>JPQL로 조회한 새로운 엔티티를 영속성 컨텍스트에 하나 더 추가하거나, 기존 엔티티를 새로 검색한 엔티티로 대체하면 어떤 문제가 발생하는 것일까?</p>\n<ul>\n<li>\n<p>영속성 컨텍스트는 기본 키 값을 기준으로 엔티티를 관리한다.</p>\n<ul>\n<li>따라서 <strong>같은 기본 키 값을 가진 엔티티는 등록이 불가</strong>하다. → \"새로운 엔티티 더 추가 불가능\"</li>\n</ul>\n</li>\n<li>\n<p><strong>영속성 컨텍스트는 엔티티의 동일성을 보장</strong>한다. </p>\n<ul>\n<li>영속성 컨텍스트에 수정 중인 데이터가 사라질 위험이 존재하는 행위는 불가하다. → \"새로운 엔티티로 대체 불가능\"</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p>이러한 이유로 기존 엔티티는 그대로 두고 새로 검색한 엔티티를 버리는 정책을 따른다.</p>\n</blockquote>\n<p><strong>📌 find() vs. JPQL</strong><br/>\n<code class=\"language-text\">em.find()</code> 메소드는 엔티티를 <strong>영속성 컨텍스트에서 먼저 찾고, 없다면 데이터베이스에서 조회</strong>한다.</p>\n<ul>\n<li>따라서 영속성 컨텍스트에 찾으려는 엔티티가 있다면, 메모리에서 바로 찾으므로 성능상 이점이 있다. (1차 캐시)</li>\n</ul>\n<p>하지만 <strong>JPQL은 항상 데이터베이스에 SQL을 실행해서 결과를 조회</strong>한다.</p>\n<ul>\n<li>동일한 엔티티를 조회할 때마다 데이터베이스에서 조회하지만, 첫 조회 이후 해당 엔티티가 영속성 컨텍스트에 등록되어 있기 때문에, 위에서 언급한 정책에 따라 데이터베이스에서 조회한 엔티티를 버리고, 기존 엔티티를 반환한다.</li>\n</ul>\n<h3>➰ JPQL과 플러시 모드</h3>\n<blockquote>\n<p><strong>플러시</strong></p>\n<ul>\n<li>영속성 컨텍스트의 변경 내역을 데이터베이스에 동기화하는 것이다.</li>\n<li>JPA는 플러시가 일어날 때 영속성 컨텍스트에 등록, 수정, 삭제한 엔티티를 찾아 SQL을 만들고 데이터베이스에 반영한다.</li>\n<li>플러시 호출 메소드가 있지만, 보통 플러시 모드에 따라 커밋 직전이나 쿼리 실행 직전에 자동으로 호출된다.</li>\n</ul>\n</blockquote>\n<p>플러시 모드는 <code class=\"language-text\">FlushModeType.AUTO</code> 가 기본값이다. </p>\n<ul>\n<li>따라서 트랜잭션 커밋 직전이나 쿼리 실행 직전에 자동으로 플러시를 호출한다.</li>\n<li>\n<p>다른 옵션으로는 <code class=\"language-text\">FlushModeType.COMMIT</code> 이 있는데, 이는 커밋 시에만 플러시를 호출하고 쿼리 실행 시에는 플러시를 호출하지 않는다.</p>\n<ul>\n<li>이 옵션은 성능 최적화를 위해 꼭 필요할 때만 사용하도록 한다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>📌 쿼리와 플러시 모드</strong><br/>\nJPQL은 영속성 컨텍스트에 있는 데이터를 고려하지 않고 데이터베이스에서 조회한다.</p>\n<ul>\n<li>따라서 <strong>JPQL을 실행하기 전 영속성 컨텍스트의 내용을 데이터베이스에 반영해야 한다.</strong></li>\n<li>\n<p>그렇지 않으면(<code class=\"language-text\">FlushModeType.COMMIT</code> 인 경우) 영속성 컨텍스트에는 수정된 엔티티의 내용이 데이터베이스에는 반영되지 않아 원치 않는 결과를 만나게 된다.</p>\n<ul>\n<li><code class=\"language-text\">setFlushMode()</code> 메소드로 플러시 모드를 설정해줄 수 있다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>📌 플러시 모드와 최적화</strong><br/>\n그렇다면 <code class=\"language-text\">COMMIT</code> 모드는 왜 사용하는 것일까?</p>\n<ul>\n<li>잘못하면 데이터 무결성에 심각한 피해를 줄 수 있는 위험이 있는 모드라 생각된다.</li>\n<li>하지만, <strong>플러시를 너무 자주 일으키는 상황</strong>에 이 모드를 사용하면, 쿼리 시 발생하는 <strong>플러시 횟수를 줄여 성능 최적화에 도움</strong>이 될 수 있다.</li>\n</ul>\n<p>또한, JPA를 사용하지 않고, JDBC를 직접 사용해서 SQL을 실행할 때도 플러시 모드를 고민해야 한다.</p>\n<ul>\n<li>\n<p>JPA를 통하지 않고 직접 쿼리를 실행하면 JPA는 JDBC가 실행한 쿼리를 인식할 방법이 없다.</p>\n<ul>\n<li>따라서 별도의 JDBC 호출은 플러시 모드를 <code class=\"language-text\">AUTO</code> 설정해도 플러시가 발생하지 않는다.</li>\n</ul>\n</li>\n<li>이때, 쿼리 실행 직전에 <code class=\"language-text\">em.flush()</code> 를 호출해 내용을 동기화하는 것이 안전하다.</li>\n</ul>\n<h2>📕 출처</h2>\n<p><strong>자바 ORM 표준 JPA 프로그래밍</strong> - 김영한</p>","frontmatter":{"title":"📚 10. 객체지향 쿼리 언어","date":"March 29, 2022","update":"March 29, 2022","tags":["Java","JPA","SpringBoot"],"series":"📚 ORM 표준 JPA"},"fields":{"slug":"/[JPA]10/","readingTime":{"minutes":77.84}}},"seriesList":{"edges":[{"node":{"id":"66d0397b-0a88-53f8-9e40-01878853acdd","fields":{"slug":"/[JPA]1/"},"frontmatter":{"title":"📚 1. JPA 소개"}}},{"node":{"id":"f86fa867-f096-52ce-854a-ef00e49ebcdb","fields":{"slug":"/[JPA]2/"},"frontmatter":{"title":"📚 2. JPA 시작"}}},{"node":{"id":"ffb8392d-d300-51c1-8e71-a8943ef4b58d","fields":{"slug":"/[JPA]3/"},"frontmatter":{"title":"📚 3. 영속성 관리"}}},{"node":{"id":"f45d0c27-c0da-5191-8c86-2aef34b75f27","fields":{"slug":"/[JPA]4/"},"frontmatter":{"title":"📚 4. 엔티티 매핑"}}},{"node":{"id":"c710307c-927c-5c1b-80fb-c45a4ff20616","fields":{"slug":"/[JPA]5/"},"frontmatter":{"title":"📚 5. 연관관계 매핑 기초"}}},{"node":{"id":"24c890e9-eebe-56bf-9db2-8660dcb3b783","fields":{"slug":"/[JPA]6/"},"frontmatter":{"title":"📚 6. 다양한 연관관계 매핑"}}},{"node":{"id":"26e75089-52ac-5b50-98c9-c2806068b034","fields":{"slug":"/[JPA]7/"},"frontmatter":{"title":"📚 7. 고급 매핑"}}},{"node":{"id":"ac8c493e-a661-53a5-989d-b84fcb728ed1","fields":{"slug":"/[JPA]8/"},"frontmatter":{"title":"📚 8. 프록시와 연관관계 관리"}}},{"node":{"id":"5003d7a8-381f-550d-aecd-28caba14aba9","fields":{"slug":"/[JPA]9/"},"frontmatter":{"title":"📚 9. 값 타입"}}},{"node":{"id":"a41dc548-d976-533a-a680-96e86a627d35","fields":{"slug":"/[JPA]10/"},"frontmatter":{"title":"📚 10. 객체지향 쿼리 언어"}}},{"node":{"id":"4ef1a134-ac1d-5e69-9f85-7c1b5d7a8244","fields":{"slug":"/[JPA]11/"},"frontmatter":{"title":"📚 11. 웹 애플리케이션 제작"}}},{"node":{"id":"1a74ae89-3758-5cb9-938c-b8238d176c8c","fields":{"slug":"/[JPA]12/"},"frontmatter":{"title":"📚 12. 스프링 데이터 JPA"}}},{"node":{"id":"5900f638-1417-5a4a-a147-a228540a920b","fields":{"slug":"/[JPA]13/"},"frontmatter":{"title":"📚 13. 웹 애플리케이션과 영속성 관리"}}},{"node":{"id":"5f07d9ea-eadc-54ea-90b2-efe93297170f","fields":{"slug":"/[JPA]14/"},"frontmatter":{"title":"📚 14. 컬렉션과 부가 기능"}}},{"node":{"id":"838bd515-9bd3-5d4b-8f49-723d3f55688c","fields":{"slug":"/[JPA]15/"},"frontmatter":{"title":"📚 15. 고급 주제와 성능 최적화"}}},{"node":{"id":"1f449b33-36ba-58f9-915f-be058ee6ba3e","fields":{"slug":"/[JPA]16/"},"frontmatter":{"title":"📚 16. 트랜잭션과 락, 2차 캐시"}}}]},"previous":{"fields":{"slug":"/[BOJ]14499/"},"frontmatter":{"title":"👩‍💻 14499. 주사위 굴리기"}},"next":{"fields":{"slug":"/[BOJ]15685/"},"frontmatter":{"title":"👩‍💻 15685. 드래곤 커브"}}},"pageContext":{"id":"a41dc548-d976-533a-a680-96e86a627d35","series":"📚 ORM 표준 JPA","previousPostId":"9db6b43b-963a-5ebd-b72b-69936cf37858","nextPostId":"6a79cddd-dc1b-5e34-8a84-af313c37de0e"}},"staticQueryHashes":[]}